From 008ac8d10d3655a233db0096a3ba63ac72cf6d8b Mon Sep 17 00:00:00 2001 From: Erik Montnemery Date: Wed, 31 Aug 2022 11:30:45 +0200 Subject: [PATCH] Improve statistics metadata WS API (#77209) --- .../components/recorder/statistics.py | 39 +- homeassistant/components/sensor/recorder.py | 6 +- tests/components/demo/test_init.py | 6 +- tests/components/history/test_init.py | 31 +- tests/components/recorder/test_statistics.py | 6 +- .../components/recorder/test_websocket_api.py | 15 +- tests/components/sensor/test_recorder.py | 464 +++++++++++------- 7 files changed, 360 insertions(+), 207 deletions(-) diff --git a/homeassistant/components/recorder/statistics.py b/homeassistant/components/recorder/statistics.py index 1b0a4e64897..0a9e29747a9 100644 --- a/homeassistant/components/recorder/statistics.py +++ b/homeassistant/components/recorder/statistics.py @@ -826,27 +826,28 @@ def list_statistic_ids( a recorder platform for statistic_ids which will be added in the next statistics period. """ - units = hass.config.units result = {} + def _display_unit(hass: HomeAssistant, unit: str | None) -> str | None: + if unit is None: + return None + return _configured_unit(unit, hass.config.units) + # Query the database with session_scope(hass=hass) as session: metadata = get_metadata_with_session( hass, session, statistic_type=statistic_type, statistic_ids=statistic_ids ) - for _, meta in metadata.values(): - if (unit := meta["unit_of_measurement"]) is not None: - # Display unit according to user settings - unit = _configured_unit(unit, units) - meta["unit_of_measurement"] = unit - result = { meta["statistic_id"]: { "has_mean": meta["has_mean"], "has_sum": meta["has_sum"], "name": meta["name"], "source": meta["source"], + "display_unit_of_measurement": _display_unit( + hass, meta["unit_of_measurement"] + ), "unit_of_measurement": meta["unit_of_measurement"], } for _, meta in metadata.values() @@ -860,14 +861,19 @@ def list_statistic_ids( hass, statistic_ids=statistic_ids, statistic_type=statistic_type ) - for statistic_id, info in platform_statistic_ids.items(): - if (unit := info["unit_of_measurement"]) is not None: - # Display unit according to user settings - unit = _configured_unit(unit, units) - platform_statistic_ids[statistic_id]["unit_of_measurement"] = unit - - for key, value in platform_statistic_ids.items(): - result.setdefault(key, value) + for key, meta in platform_statistic_ids.items(): + if key in result: + continue + result[key] = { + "has_mean": meta["has_mean"], + "has_sum": meta["has_sum"], + "name": meta["name"], + "source": meta["source"], + "display_unit_of_measurement": _display_unit( + hass, meta["unit_of_measurement"] + ), + "unit_of_measurement": meta["unit_of_measurement"], + } # Return a list of statistic_id + metadata return [ @@ -877,7 +883,8 @@ def list_statistic_ids( "has_sum": info["has_sum"], "name": info.get("name"), "source": info["source"], - "unit_of_measurement": info["unit_of_measurement"], + "display_unit_of_measurement": info["display_unit_of_measurement"], + "statistics_unit_of_measurement": info["unit_of_measurement"], } for _id, info in result.items() ] diff --git a/homeassistant/components/sensor/recorder.py b/homeassistant/components/sensor/recorder.py index ea7d129a9c3..8c70a2c3ffe 100644 --- a/homeassistant/components/sensor/recorder.py +++ b/homeassistant/components/sensor/recorder.py @@ -622,7 +622,7 @@ def list_statistic_ids( """Return all or filtered statistic_ids and meta data.""" entities = _get_sensor_states(hass) - result = {} + result: dict[str, StatisticMetaData] = {} for state in entities: state_class = state.attributes[ATTR_STATE_CLASS] @@ -647,7 +647,9 @@ def list_statistic_ids( result[state.entity_id] = { "has_mean": "mean" in provided_statistics, "has_sum": "sum" in provided_statistics, + "name": None, "source": RECORDER_DOMAIN, + "statistic_id": state.entity_id, "unit_of_measurement": native_unit, } continue @@ -659,7 +661,9 @@ def list_statistic_ids( result[state.entity_id] = { "has_mean": "mean" in provided_statistics, "has_sum": "sum" in provided_statistics, + "name": None, "source": RECORDER_DOMAIN, + "statistic_id": state.entity_id, "unit_of_measurement": statistics_unit, } diff --git a/tests/components/demo/test_init.py b/tests/components/demo/test_init.py index 5a407ba25fc..1577b411c23 100644 --- a/tests/components/demo/test_init.py +++ b/tests/components/demo/test_init.py @@ -62,20 +62,22 @@ async def test_demo_statistics(hass, recorder_mock): list_statistic_ids, hass ) assert { + "display_unit_of_measurement": "°C", "has_mean": True, "has_sum": False, "name": "Outdoor temperature", "source": "demo", "statistic_id": "demo:temperature_outdoor", - "unit_of_measurement": "°C", + "statistics_unit_of_measurement": "°C", } in statistic_ids assert { + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "name": "Energy consumption 1", "source": "demo", "statistic_id": "demo:energy_consumption_kwh", - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", } in statistic_ids diff --git a/tests/components/history/test_init.py b/tests/components/history/test_init.py index 5eb4894c72a..854ddb76191 100644 --- a/tests/components/history/test_init.py +++ b/tests/components/history/test_init.py @@ -1118,18 +1118,24 @@ async def test_statistics_during_period_bad_end_time( @pytest.mark.parametrize( - "units, attributes, unit", + "units, attributes, display_unit, statistics_unit", [ - (IMPERIAL_SYSTEM, POWER_SENSOR_ATTRIBUTES, "W"), - (METRIC_SYSTEM, POWER_SENSOR_ATTRIBUTES, "W"), - (IMPERIAL_SYSTEM, TEMPERATURE_SENSOR_ATTRIBUTES, "°F"), - (METRIC_SYSTEM, TEMPERATURE_SENSOR_ATTRIBUTES, "°C"), - (IMPERIAL_SYSTEM, PRESSURE_SENSOR_ATTRIBUTES, "psi"), - (METRIC_SYSTEM, PRESSURE_SENSOR_ATTRIBUTES, "Pa"), + (IMPERIAL_SYSTEM, POWER_SENSOR_ATTRIBUTES, "W", "W"), + (METRIC_SYSTEM, POWER_SENSOR_ATTRIBUTES, "W", "W"), + (IMPERIAL_SYSTEM, TEMPERATURE_SENSOR_ATTRIBUTES, "°F", "°C"), + (METRIC_SYSTEM, TEMPERATURE_SENSOR_ATTRIBUTES, "°C", "°C"), + (IMPERIAL_SYSTEM, PRESSURE_SENSOR_ATTRIBUTES, "psi", "Pa"), + (METRIC_SYSTEM, PRESSURE_SENSOR_ATTRIBUTES, "Pa", "Pa"), ], ) async def test_list_statistic_ids( - hass, hass_ws_client, recorder_mock, units, attributes, unit + hass, + hass_ws_client, + recorder_mock, + units, + attributes, + display_unit, + statistics_unit, ): """Test list_statistic_ids.""" now = dt_util.utcnow() @@ -1158,7 +1164,8 @@ async def test_list_statistic_ids( "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": unit, + "display_unit_of_measurement": display_unit, + "statistics_unit_of_measurement": statistics_unit, } ] @@ -1178,7 +1185,8 @@ async def test_list_statistic_ids( "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": unit, + "display_unit_of_measurement": display_unit, + "statistics_unit_of_measurement": statistics_unit, } ] @@ -1200,7 +1208,8 @@ async def test_list_statistic_ids( "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": unit, + "display_unit_of_measurement": display_unit, + "statistics_unit_of_measurement": statistics_unit, } ] diff --git a/tests/components/recorder/test_statistics.py b/tests/components/recorder/test_statistics.py index 5bc8aa76a00..970a7feac61 100644 --- a/tests/components/recorder/test_statistics.py +++ b/tests/components/recorder/test_statistics.py @@ -524,12 +524,13 @@ async def test_import_statistics( statistic_ids = list_statistic_ids(hass) assert statistic_ids == [ { + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "statistic_id": statistic_id, "name": "Total imported energy", "source": source, - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", } ] metadata = get_metadata(hass, statistic_ids=(statistic_id,)) @@ -616,12 +617,13 @@ async def test_import_statistics( statistic_ids = list_statistic_ids(hass) assert statistic_ids == [ { + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "statistic_id": statistic_id, "name": "Total imported energy renamed", "source": source, - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", } ] metadata = get_metadata(hass, statistic_ids=(statistic_id,)) diff --git a/tests/components/recorder/test_websocket_api.py b/tests/components/recorder/test_websocket_api.py index b604cc53e6c..269cebcba9f 100644 --- a/tests/components/recorder/test_websocket_api.py +++ b/tests/components/recorder/test_websocket_api.py @@ -226,11 +226,12 @@ async def test_update_statistics_metadata( assert response["result"] == [ { "statistic_id": "sensor.test", + "display_unit_of_measurement": "W", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "W", + "statistics_unit_of_measurement": "W", } ] @@ -252,11 +253,12 @@ async def test_update_statistics_metadata( assert response["result"] == [ { "statistic_id": "sensor.test", + "display_unit_of_measurement": new_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": new_unit, + "statistics_unit_of_measurement": new_unit, } ] @@ -526,11 +528,12 @@ async def test_get_statistics_metadata( assert response["result"] == [ { "statistic_id": "sensor.test", + "display_unit_of_measurement": unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": unit, + "statistics_unit_of_measurement": unit, } ] @@ -552,11 +555,12 @@ async def test_get_statistics_metadata( assert response["result"] == [ { "statistic_id": "sensor.test", + "display_unit_of_measurement": unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": unit, + "statistics_unit_of_measurement": unit, } ] @@ -646,12 +650,13 @@ async def test_import_statistics( statistic_ids = list_statistic_ids(hass) # TODO assert statistic_ids == [ { + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "statistic_id": statistic_id, "name": "Total imported energy", "source": source, - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", } ] metadata = get_metadata(hass, statistic_ids=(statistic_id,)) diff --git a/tests/components/sensor/test_recorder.py b/tests/components/sensor/test_recorder.py index 64fd1884ae6..e7421e6a616 100644 --- a/tests/components/sensor/test_recorder.py +++ b/tests/components/sensor/test_recorder.py @@ -76,24 +76,32 @@ def set_time_zone(): @pytest.mark.parametrize( - "device_class,unit,native_unit,mean,min,max", + "device_class,state_unit,display_unit,statistics_unit,mean,min,max", [ - (None, "%", "%", 13.050847, -10, 30), - ("battery", "%", "%", 13.050847, -10, 30), - ("battery", None, None, 13.050847, -10, 30), - ("humidity", "%", "%", 13.050847, -10, 30), - ("humidity", None, None, 13.050847, -10, 30), - ("pressure", "Pa", "Pa", 13.050847, -10, 30), - ("pressure", "hPa", "Pa", 1305.0847, -1000, 3000), - ("pressure", "mbar", "Pa", 1305.0847, -1000, 3000), - ("pressure", "inHg", "Pa", 44195.25, -33863.89, 101591.67), - ("pressure", "psi", "Pa", 89982.42, -68947.57, 206842.71), - ("temperature", "°C", "°C", 13.050847, -10, 30), - ("temperature", "°F", "°C", -10.52731, -23.33333, -1.111111), + (None, "%", "%", "%", 13.050847, -10, 30), + ("battery", "%", "%", "%", 13.050847, -10, 30), + ("battery", None, None, None, 13.050847, -10, 30), + ("humidity", "%", "%", "%", 13.050847, -10, 30), + ("humidity", None, None, None, 13.050847, -10, 30), + ("pressure", "Pa", "Pa", "Pa", 13.050847, -10, 30), + ("pressure", "hPa", "Pa", "Pa", 1305.0847, -1000, 3000), + ("pressure", "mbar", "Pa", "Pa", 1305.0847, -1000, 3000), + ("pressure", "inHg", "Pa", "Pa", 44195.25, -33863.89, 101591.67), + ("pressure", "psi", "Pa", "Pa", 89982.42, -68947.57, 206842.71), + ("temperature", "°C", "°C", "°C", 13.050847, -10, 30), + ("temperature", "°F", "°C", "°C", -10.52731, -23.33333, -1.111111), ], ) def test_compile_hourly_statistics( - hass_recorder, caplog, device_class, unit, native_unit, mean, min, max + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + mean, + min, + max, ): """Test compiling hourly statistics.""" zero = dt_util.utcnow() @@ -103,7 +111,7 @@ def test_compile_hourly_statistics( attributes = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states(hass, zero, "sensor.test1", attributes) hist = history.get_significant_states(hass, zero, four) @@ -115,11 +123,12 @@ def test_compile_hourly_statistics( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, zero, period="5minute") @@ -142,13 +151,13 @@ def test_compile_hourly_statistics( @pytest.mark.parametrize( - "device_class,unit,native_unit", + "device_class,state_unit,display_unit,statistics_unit", [ - (None, "%", "%"), + (None, "%", "%", "%"), ], ) def test_compile_hourly_statistics_purged_state_changes( - hass_recorder, caplog, device_class, unit, native_unit + hass_recorder, caplog, device_class, state_unit, display_unit, statistics_unit ): """Test compiling hourly statistics.""" zero = dt_util.utcnow() @@ -158,7 +167,7 @@ def test_compile_hourly_statistics_purged_state_changes( attributes = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states(hass, zero, "sensor.test1", attributes) hist = history.get_significant_states(hass, zero, four) @@ -181,12 +190,13 @@ def test_compile_hourly_statistics_purged_state_changes( statistic_ids = list_statistic_ids(hass) assert statistic_ids == [ { + "display_unit_of_measurement": display_unit, "statistic_id": "sensor.test1", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, zero, period="5minute") @@ -250,27 +260,30 @@ def test_compile_hourly_statistics_unsupported(hass_recorder, caplog, attributes assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": "°C", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "°C", + "statistics_unit_of_measurement": "°C", }, { "statistic_id": "sensor.test6", + "display_unit_of_measurement": "°C", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "°C", + "statistics_unit_of_measurement": "°C", }, { "statistic_id": "sensor.test7", + "display_unit_of_measurement": "°C", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "°C", + "statistics_unit_of_measurement": "°C", }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -320,20 +333,20 @@ def test_compile_hourly_statistics_unsupported(hass_recorder, caplog, attributes @pytest.mark.parametrize("state_class", ["total"]) @pytest.mark.parametrize( - "units,device_class,unit,display_unit,factor", + "units,device_class,state_unit,display_unit,statistics_unit,factor", [ - (IMPERIAL_SYSTEM, "energy", "kWh", "kWh", 1), - (IMPERIAL_SYSTEM, "energy", "Wh", "kWh", 1 / 1000), - (IMPERIAL_SYSTEM, "monetary", "EUR", "EUR", 1), - (IMPERIAL_SYSTEM, "monetary", "SEK", "SEK", 1), - (IMPERIAL_SYSTEM, "gas", "m³", "ft³", 35.314666711), - (IMPERIAL_SYSTEM, "gas", "ft³", "ft³", 1), - (METRIC_SYSTEM, "energy", "kWh", "kWh", 1), - (METRIC_SYSTEM, "energy", "Wh", "kWh", 1 / 1000), - (METRIC_SYSTEM, "monetary", "EUR", "EUR", 1), - (METRIC_SYSTEM, "monetary", "SEK", "SEK", 1), - (METRIC_SYSTEM, "gas", "m³", "m³", 1), - (METRIC_SYSTEM, "gas", "ft³", "m³", 0.0283168466), + (IMPERIAL_SYSTEM, "energy", "kWh", "kWh", "kWh", 1), + (IMPERIAL_SYSTEM, "energy", "Wh", "kWh", "kWh", 1 / 1000), + (IMPERIAL_SYSTEM, "monetary", "EUR", "EUR", "EUR", 1), + (IMPERIAL_SYSTEM, "monetary", "SEK", "SEK", "SEK", 1), + (IMPERIAL_SYSTEM, "gas", "m³", "ft³", "m³", 35.314666711), + (IMPERIAL_SYSTEM, "gas", "ft³", "ft³", "m³", 1), + (METRIC_SYSTEM, "energy", "kWh", "kWh", "kWh", 1), + (METRIC_SYSTEM, "energy", "Wh", "kWh", "kWh", 1 / 1000), + (METRIC_SYSTEM, "monetary", "EUR", "EUR", "EUR", 1), + (METRIC_SYSTEM, "monetary", "SEK", "SEK", "SEK", 1), + (METRIC_SYSTEM, "gas", "m³", "m³", "m³", 1), + (METRIC_SYSTEM, "gas", "ft³", "m³", "m³", 0.0283168466), ], ) async def test_compile_hourly_sum_statistics_amount( @@ -344,8 +357,9 @@ async def test_compile_hourly_sum_statistics_amount( units, state_class, device_class, - unit, + state_unit, display_unit, + statistics_unit, factor, ): """Test compiling hourly statistics.""" @@ -361,7 +375,7 @@ async def test_compile_hourly_sum_statistics_amount( attributes = { "device_class": device_class, "state_class": state_class, - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, "last_reset": None, } seq = [10, 15, 20, 10, 30, 40, 50, 60, 70] @@ -385,11 +399,12 @@ async def test_compile_hourly_sum_statistics_amount( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": display_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, period0, period="5minute") @@ -496,18 +511,25 @@ async def test_compile_hourly_sum_statistics_amount( @pytest.mark.parametrize("state_class", ["total"]) @pytest.mark.parametrize( - "device_class,unit,native_unit,factor", + "device_class,state_unit,display_unit,statistics_unit,factor", [ - ("energy", "kWh", "kWh", 1), - ("energy", "Wh", "kWh", 1 / 1000), - ("monetary", "EUR", "EUR", 1), - ("monetary", "SEK", "SEK", 1), - ("gas", "m³", "m³", 1), - ("gas", "ft³", "m³", 0.0283168466), + ("energy", "kWh", "kWh", "kWh", 1), + ("energy", "Wh", "kWh", "kWh", 1 / 1000), + ("monetary", "EUR", "EUR", "EUR", 1), + ("monetary", "SEK", "SEK", "SEK", 1), + ("gas", "m³", "m³", "m³", 1), + ("gas", "ft³", "m³", "m³", 0.0283168466), ], ) def test_compile_hourly_sum_statistics_amount_reset_every_state_change( - hass_recorder, caplog, state_class, device_class, unit, native_unit, factor + hass_recorder, + caplog, + state_class, + device_class, + state_unit, + display_unit, + statistics_unit, + factor, ): """Test compiling hourly statistics.""" zero = dt_util.utcnow() @@ -517,7 +539,7 @@ def test_compile_hourly_sum_statistics_amount_reset_every_state_change( attributes = { "device_class": device_class, "state_class": state_class, - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, "last_reset": None, } seq = [10, 15, 15, 15, 20, 20, 20, 25] @@ -566,11 +588,12 @@ def test_compile_hourly_sum_statistics_amount_reset_every_state_change( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, zero, period="5minute") @@ -607,13 +630,20 @@ def test_compile_hourly_sum_statistics_amount_reset_every_state_change( @pytest.mark.parametrize("state_class", ["total"]) @pytest.mark.parametrize( - "device_class,unit,native_unit,factor", + "device_class,state_unit,display_unit,statistics_unit,factor", [ - ("energy", "kWh", "kWh", 1), + ("energy", "kWh", "kWh", "kWh", 1), ], ) def test_compile_hourly_sum_statistics_amount_invalid_last_reset( - hass_recorder, caplog, state_class, device_class, unit, native_unit, factor + hass_recorder, + caplog, + state_class, + device_class, + state_unit, + display_unit, + statistics_unit, + factor, ): """Test compiling hourly statistics.""" zero = dt_util.utcnow() @@ -623,7 +653,7 @@ def test_compile_hourly_sum_statistics_amount_invalid_last_reset( attributes = { "device_class": device_class, "state_class": state_class, - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, "last_reset": None, } seq = [10, 15, 15, 15, 20, 20, 20, 25] @@ -657,11 +687,12 @@ def test_compile_hourly_sum_statistics_amount_invalid_last_reset( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, zero, period="5minute") @@ -686,13 +717,20 @@ def test_compile_hourly_sum_statistics_amount_invalid_last_reset( @pytest.mark.parametrize("state_class", ["total"]) @pytest.mark.parametrize( - "device_class,unit,native_unit,factor", + "device_class,state_unit,display_unit,statistics_unit,factor", [ - ("energy", "kWh", "kWh", 1), + ("energy", "kWh", "kWh", "kWh", 1), ], ) def test_compile_hourly_sum_statistics_nan_inf_state( - hass_recorder, caplog, state_class, device_class, unit, native_unit, factor + hass_recorder, + caplog, + state_class, + device_class, + state_unit, + display_unit, + statistics_unit, + factor, ): """Test compiling hourly statistics with nan and inf states.""" zero = dt_util.utcnow() @@ -702,7 +740,7 @@ def test_compile_hourly_sum_statistics_nan_inf_state( attributes = { "device_class": device_class, "state_class": state_class, - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, "last_reset": None, } seq = [10, math.nan, 15, 15, 20, math.inf, 20, 10] @@ -732,11 +770,12 @@ def test_compile_hourly_sum_statistics_nan_inf_state( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, zero, period="5minute") @@ -780,9 +819,9 @@ def test_compile_hourly_sum_statistics_nan_inf_state( ) @pytest.mark.parametrize("state_class", ["total_increasing"]) @pytest.mark.parametrize( - "device_class,unit,native_unit,factor", + "device_class,state_unit,display_unit,statistics_unit,factor", [ - ("energy", "kWh", "kWh", 1), + ("energy", "kWh", "kWh", "kWh", 1), ], ) def test_compile_hourly_sum_statistics_negative_state( @@ -793,8 +832,9 @@ def test_compile_hourly_sum_statistics_negative_state( warning_2, state_class, device_class, - unit, - native_unit, + state_unit, + display_unit, + statistics_unit, factor, ): """Test compiling hourly statistics with negative states.""" @@ -815,7 +855,7 @@ def test_compile_hourly_sum_statistics_negative_state( attributes = { "device_class": device_class, "state_class": state_class, - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } seq = [15, 16, 15, 16, 20, -20, 20, 10] @@ -843,11 +883,12 @@ def test_compile_hourly_sum_statistics_negative_state( statistic_ids = list_statistic_ids(hass) assert { "name": None, + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "source": "recorder", "statistic_id": entity_id, - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } in statistic_ids stats = statistics_during_period(hass, zero, period="5minute") assert stats[entity_id] == [ @@ -875,18 +916,24 @@ def test_compile_hourly_sum_statistics_negative_state( @pytest.mark.parametrize( - "device_class,unit,native_unit,factor", + "device_class,state_unit,display_unit,statistics_unit,factor", [ - ("energy", "kWh", "kWh", 1), - ("energy", "Wh", "kWh", 1 / 1000), - ("monetary", "EUR", "EUR", 1), - ("monetary", "SEK", "SEK", 1), - ("gas", "m³", "m³", 1), - ("gas", "ft³", "m³", 0.0283168466), + ("energy", "kWh", "kWh", "kWh", 1), + ("energy", "Wh", "kWh", "kWh", 1 / 1000), + ("monetary", "EUR", "EUR", "EUR", 1), + ("monetary", "SEK", "SEK", "SEK", 1), + ("gas", "m³", "m³", "m³", 1), + ("gas", "ft³", "m³", "m³", 0.0283168466), ], ) def test_compile_hourly_sum_statistics_total_no_reset( - hass_recorder, caplog, device_class, unit, native_unit, factor + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + factor, ): """Test compiling hourly statistics.""" period0 = dt_util.utcnow() @@ -899,7 +946,7 @@ def test_compile_hourly_sum_statistics_total_no_reset( attributes = { "device_class": device_class, "state_class": "total", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } seq = [10, 15, 20, 10, 30, 40, 50, 60, 70] @@ -922,11 +969,12 @@ def test_compile_hourly_sum_statistics_total_no_reset( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, period0, period="5minute") @@ -971,16 +1019,22 @@ def test_compile_hourly_sum_statistics_total_no_reset( @pytest.mark.parametrize( - "device_class,unit,native_unit,factor", + "device_class,state_unit,display_unit,statistics_unit,factor", [ - ("energy", "kWh", "kWh", 1), - ("energy", "Wh", "kWh", 1 / 1000), - ("gas", "m³", "m³", 1), - ("gas", "ft³", "m³", 0.0283168466), + ("energy", "kWh", "kWh", "kWh", 1), + ("energy", "Wh", "kWh", "kWh", 1 / 1000), + ("gas", "m³", "m³", "m³", 1), + ("gas", "ft³", "m³", "m³", 0.0283168466), ], ) def test_compile_hourly_sum_statistics_total_increasing( - hass_recorder, caplog, device_class, unit, native_unit, factor + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + factor, ): """Test compiling hourly statistics.""" period0 = dt_util.utcnow() @@ -993,7 +1047,7 @@ def test_compile_hourly_sum_statistics_total_increasing( attributes = { "device_class": device_class, "state_class": "total_increasing", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } seq = [10, 15, 20, 10, 30, 40, 50, 60, 70] @@ -1016,11 +1070,12 @@ def test_compile_hourly_sum_statistics_total_increasing( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, period0, period="5minute") @@ -1068,11 +1123,17 @@ def test_compile_hourly_sum_statistics_total_increasing( @pytest.mark.parametrize( - "device_class,unit,native_unit,factor", - [("energy", "kWh", "kWh", 1)], + "device_class,state_unit,display_unit,statistics_unit,factor", + [("energy", "kWh", "kWh", "kWh", 1)], ) def test_compile_hourly_sum_statistics_total_increasing_small_dip( - hass_recorder, caplog, device_class, unit, native_unit, factor + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + factor, ): """Test small dips in sensor readings do not trigger a reset.""" period0 = dt_util.utcnow() @@ -1085,7 +1146,7 @@ def test_compile_hourly_sum_statistics_total_increasing_small_dip( attributes = { "device_class": device_class, "state_class": "total_increasing", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } seq = [10, 15, 20, 19, 30, 40, 39, 60, 70] @@ -1121,11 +1182,12 @@ def test_compile_hourly_sum_statistics_total_increasing_small_dip( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, } ] stats = statistics_during_period(hass, period0, period="5minute") @@ -1214,11 +1276,12 @@ def test_compile_hourly_energy_statistics_unsupported(hass_recorder, caplog): assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", } ] stats = statistics_during_period(hass, period0, period="5minute") @@ -1305,27 +1368,30 @@ def test_compile_hourly_energy_statistics_multiple(hass_recorder, caplog): assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", }, { "statistic_id": "sensor.test2", + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", }, { "statistic_id": "sensor.test3", + "display_unit_of_measurement": "kWh", "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": "kWh", + "statistics_unit_of_measurement": "kWh", }, ] stats = statistics_during_period(hass, period0, period="5minute") @@ -1440,7 +1506,7 @@ def test_compile_hourly_energy_statistics_multiple(hass_recorder, caplog): @pytest.mark.parametrize( - "device_class,unit,value", + "device_class,state_unit,value", [ ("battery", "%", 30), ("battery", None, 30), @@ -1456,7 +1522,7 @@ def test_compile_hourly_energy_statistics_multiple(hass_recorder, caplog): ], ) def test_compile_hourly_statistics_unchanged( - hass_recorder, caplog, device_class, unit, value + hass_recorder, caplog, device_class, state_unit, value ): """Test compiling hourly statistics, with no changes during the hour.""" zero = dt_util.utcnow() @@ -1466,7 +1532,7 @@ def test_compile_hourly_statistics_unchanged( attributes = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states(hass, zero, "sensor.test1", attributes) hist = history.get_significant_states(hass, zero, four) @@ -1527,7 +1593,7 @@ def test_compile_hourly_statistics_partially_unavailable(hass_recorder, caplog): @pytest.mark.parametrize( - "device_class,unit,value", + "device_class,state_unit,value", [ ("battery", "%", 30), ("battery", None, 30), @@ -1543,7 +1609,7 @@ def test_compile_hourly_statistics_partially_unavailable(hass_recorder, caplog): ], ) def test_compile_hourly_statistics_unavailable( - hass_recorder, caplog, device_class, unit, value + hass_recorder, caplog, device_class, state_unit, value ): """Test compiling hourly statistics, with the sensor being unavailable.""" zero = dt_util.utcnow() @@ -1553,7 +1619,7 @@ def test_compile_hourly_statistics_unavailable( attributes = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states_partially_unavailable( hass, zero, "sensor.test1", attributes @@ -1600,35 +1666,42 @@ def test_compile_hourly_statistics_fails(hass_recorder, caplog): @pytest.mark.parametrize( - "state_class,device_class,unit,native_unit,statistic_type", + "state_class,device_class,state_unit,display_unit,statistics_unit,statistic_type", [ - ("measurement", "battery", "%", "%", "mean"), - ("measurement", "battery", None, None, "mean"), - ("total", "energy", "Wh", "kWh", "sum"), - ("total", "energy", "kWh", "kWh", "sum"), - ("measurement", "energy", "Wh", "kWh", "mean"), - ("measurement", "energy", "kWh", "kWh", "mean"), - ("measurement", "humidity", "%", "%", "mean"), - ("measurement", "humidity", None, None, "mean"), - ("total", "monetary", "USD", "USD", "sum"), - ("total", "monetary", "None", "None", "sum"), - ("total", "gas", "m³", "m³", "sum"), - ("total", "gas", "ft³", "m³", "sum"), - ("measurement", "monetary", "USD", "USD", "mean"), - ("measurement", "monetary", "None", "None", "mean"), - ("measurement", "gas", "m³", "m³", "mean"), - ("measurement", "gas", "ft³", "m³", "mean"), - ("measurement", "pressure", "Pa", "Pa", "mean"), - ("measurement", "pressure", "hPa", "Pa", "mean"), - ("measurement", "pressure", "mbar", "Pa", "mean"), - ("measurement", "pressure", "inHg", "Pa", "mean"), - ("measurement", "pressure", "psi", "Pa", "mean"), - ("measurement", "temperature", "°C", "°C", "mean"), - ("measurement", "temperature", "°F", "°C", "mean"), + ("measurement", "battery", "%", "%", "%", "mean"), + ("measurement", "battery", None, None, None, "mean"), + ("total", "energy", "Wh", "kWh", "kWh", "sum"), + ("total", "energy", "kWh", "kWh", "kWh", "sum"), + ("measurement", "energy", "Wh", "kWh", "kWh", "mean"), + ("measurement", "energy", "kWh", "kWh", "kWh", "mean"), + ("measurement", "humidity", "%", "%", "%", "mean"), + ("measurement", "humidity", None, None, None, "mean"), + ("total", "monetary", "USD", "USD", "USD", "sum"), + ("total", "monetary", "None", "None", "None", "sum"), + ("total", "gas", "m³", "m³", "m³", "sum"), + ("total", "gas", "ft³", "m³", "m³", "sum"), + ("measurement", "monetary", "USD", "USD", "USD", "mean"), + ("measurement", "monetary", "None", "None", "None", "mean"), + ("measurement", "gas", "m³", "m³", "m³", "mean"), + ("measurement", "gas", "ft³", "m³", "m³", "mean"), + ("measurement", "pressure", "Pa", "Pa", "Pa", "mean"), + ("measurement", "pressure", "hPa", "Pa", "Pa", "mean"), + ("measurement", "pressure", "mbar", "Pa", "Pa", "mean"), + ("measurement", "pressure", "inHg", "Pa", "Pa", "mean"), + ("measurement", "pressure", "psi", "Pa", "Pa", "mean"), + ("measurement", "temperature", "°C", "°C", "°C", "mean"), + ("measurement", "temperature", "°F", "°C", "°C", "mean"), ], ) def test_list_statistic_ids( - hass_recorder, caplog, state_class, device_class, unit, native_unit, statistic_type + hass_recorder, + caplog, + state_class, + device_class, + state_unit, + display_unit, + statistics_unit, + statistic_type, ): """Test listing future statistic ids.""" hass = hass_recorder() @@ -1638,18 +1711,19 @@ def test_list_statistic_ids( "device_class": device_class, "last_reset": 0, "state_class": state_class, - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } hass.states.set("sensor.test1", 0, attributes=attributes) statistic_ids = list_statistic_ids(hass) assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": statistic_type == "mean", "has_sum": statistic_type == "sum", "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, }, ] for stat_type in ["mean", "sum", "dogs"]: @@ -1658,11 +1732,12 @@ def test_list_statistic_ids( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": statistic_type == "mean", "has_sum": statistic_type == "sum", "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, }, ] else: @@ -1697,16 +1772,24 @@ def test_list_statistic_ids_unsupported(hass_recorder, caplog, _attributes): @pytest.mark.parametrize( - "device_class,unit,native_unit,mean,min,max", + "device_class,state_unit,display_unit,statistics_unit,mean,min,max", [ - (None, None, None, 13.050847, -10, 30), - (None, "%", "%", 13.050847, -10, 30), - ("battery", "%", "%", 13.050847, -10, 30), - ("battery", None, None, 13.050847, -10, 30), + (None, None, None, None, 13.050847, -10, 30), + (None, "%", "%", "%", 13.050847, -10, 30), + ("battery", "%", "%", "%", 13.050847, -10, 30), + ("battery", None, None, None, 13.050847, -10, 30), ], ) def test_compile_hourly_statistics_changing_units_1( - hass_recorder, caplog, device_class, unit, native_unit, mean, min, max + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + mean, + min, + max, ): """Test compiling hourly statistics where units change from one hour to the next.""" zero = dt_util.utcnow() @@ -1716,7 +1799,7 @@ def test_compile_hourly_statistics_changing_units_1( attributes = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states(hass, zero, "sensor.test1", attributes) attributes["unit_of_measurement"] = "cats" @@ -1738,11 +1821,12 @@ def test_compile_hourly_statistics_changing_units_1( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -1766,17 +1850,18 @@ def test_compile_hourly_statistics_changing_units_1( wait_recording_done(hass) assert ( "The unit of sensor.test1 (cats) does not match the unit of already compiled " - f"statistics ({native_unit})" in caplog.text + f"statistics ({display_unit})" in caplog.text ) statistic_ids = list_statistic_ids(hass) assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -1799,16 +1884,24 @@ def test_compile_hourly_statistics_changing_units_1( @pytest.mark.parametrize( - "device_class,unit,native_unit,mean,min,max", + "device_class,state_unit,display_unit,statistics_unit,mean,min,max", [ - (None, None, None, 13.050847, -10, 30), - (None, "%", "%", 13.050847, -10, 30), - ("battery", "%", "%", 13.050847, -10, 30), - ("battery", None, None, 13.050847, -10, 30), + (None, None, None, None, 13.050847, -10, 30), + (None, "%", "%", "%", 13.050847, -10, 30), + ("battery", "%", "%", "%", 13.050847, -10, 30), + ("battery", None, None, None, 13.050847, -10, 30), ], ) def test_compile_hourly_statistics_changing_units_2( - hass_recorder, caplog, device_class, unit, native_unit, mean, min, max + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + mean, + min, + max, ): """Test compiling hourly statistics where units change during an hour.""" zero = dt_util.utcnow() @@ -1818,7 +1911,7 @@ def test_compile_hourly_statistics_changing_units_2( attributes = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states(hass, zero, "sensor.test1", attributes) attributes["unit_of_measurement"] = "cats" @@ -1837,11 +1930,12 @@ def test_compile_hourly_statistics_changing_units_2( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": "cats", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "cats", + "statistics_unit_of_measurement": "cats", }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -1851,16 +1945,24 @@ def test_compile_hourly_statistics_changing_units_2( @pytest.mark.parametrize( - "device_class,unit,native_unit,mean,min,max", + "device_class,state_unit,display_unit,statistics_unit,mean,min,max", [ - (None, None, None, 13.050847, -10, 30), - (None, "%", "%", 13.050847, -10, 30), - ("battery", "%", "%", 13.050847, -10, 30), - ("battery", None, None, 13.050847, -10, 30), + (None, None, None, None, 13.050847, -10, 30), + (None, "%", "%", "%", 13.050847, -10, 30), + ("battery", "%", "%", "%", 13.050847, -10, 30), + ("battery", None, None, None, 13.050847, -10, 30), ], ) def test_compile_hourly_statistics_changing_units_3( - hass_recorder, caplog, device_class, unit, native_unit, mean, min, max + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + mean, + min, + max, ): """Test compiling hourly statistics where units change from one hour to the next.""" zero = dt_util.utcnow() @@ -1870,7 +1972,7 @@ def test_compile_hourly_statistics_changing_units_3( attributes = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states(hass, zero, "sensor.test1", attributes) four, _states = record_states( @@ -1892,11 +1994,12 @@ def test_compile_hourly_statistics_changing_units_3( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -1919,16 +2022,19 @@ def test_compile_hourly_statistics_changing_units_3( do_adhoc_statistics(hass, start=zero + timedelta(minutes=10)) wait_recording_done(hass) assert "The unit of sensor.test1 is changing" in caplog.text - assert f"matches the unit of already compiled statistics ({unit})" in caplog.text + assert ( + f"matches the unit of already compiled statistics ({state_unit})" in caplog.text + ) statistic_ids = list_statistic_ids(hass) assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": display_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": native_unit, + "statistics_unit_of_measurement": statistics_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -1979,11 +2085,12 @@ def test_compile_hourly_statistics_changing_device_class_1( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": state_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": state_unit, + "statistics_unit_of_measurement": state_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -2027,11 +2134,12 @@ def test_compile_hourly_statistics_changing_device_class_1( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": state_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": state_unit, + "statistics_unit_of_measurement": state_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -2083,11 +2191,12 @@ def test_compile_hourly_statistics_changing_device_class_2( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": statistic_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": statistic_unit, + "statistics_unit_of_measurement": statistic_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -2131,11 +2240,12 @@ def test_compile_hourly_statistics_changing_device_class_2( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": statistic_unit, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": statistic_unit, + "statistics_unit_of_measurement": statistic_unit, }, ] stats = statistics_during_period(hass, zero, period="5minute") @@ -2158,13 +2268,21 @@ def test_compile_hourly_statistics_changing_device_class_2( @pytest.mark.parametrize( - "device_class,unit,native_unit,mean,min,max", + "device_class,state_unit,display_unit,statistics_unit,mean,min,max", [ - (None, None, None, 13.050847, -10, 30), + (None, None, None, None, 13.050847, -10, 30), ], ) def test_compile_hourly_statistics_changing_statistics( - hass_recorder, caplog, device_class, unit, native_unit, mean, min, max + hass_recorder, + caplog, + device_class, + state_unit, + display_unit, + statistics_unit, + mean, + min, + max, ): """Test compiling hourly statistics where units change during an hour.""" period0 = dt_util.utcnow() @@ -2176,12 +2294,12 @@ def test_compile_hourly_statistics_changing_statistics( attributes_1 = { "device_class": device_class, "state_class": "measurement", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } attributes_2 = { "device_class": device_class, "state_class": "total_increasing", - "unit_of_measurement": unit, + "unit_of_measurement": state_unit, } four, states = record_states(hass, period0, "sensor.test1", attributes_1) do_adhoc_statistics(hass, start=period0) @@ -2190,11 +2308,12 @@ def test_compile_hourly_statistics_changing_statistics( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": None, "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": None, + "statistics_unit_of_measurement": None, }, ] metadata = get_metadata(hass, statistic_ids=("sensor.test1",)) @@ -2224,11 +2343,12 @@ def test_compile_hourly_statistics_changing_statistics( assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": None, "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": None, + "statistics_unit_of_measurement": None, }, ] metadata = get_metadata(hass, statistic_ids=("sensor.test1",)) @@ -2416,35 +2536,39 @@ def test_compile_statistics_hourly_daily_monthly_summary(hass_recorder, caplog): assert statistic_ids == [ { "statistic_id": "sensor.test1", + "display_unit_of_measurement": "%", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "%", + "statistics_unit_of_measurement": "%", }, { "statistic_id": "sensor.test2", + "display_unit_of_measurement": "%", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "%", + "statistics_unit_of_measurement": "%", }, { "statistic_id": "sensor.test3", + "display_unit_of_measurement": "%", "has_mean": True, "has_sum": False, "name": None, "source": "recorder", - "unit_of_measurement": "%", + "statistics_unit_of_measurement": "%", }, { "statistic_id": "sensor.test4", + "display_unit_of_measurement": "EUR", "has_mean": False, "has_sum": True, "name": None, "source": "recorder", - "unit_of_measurement": "EUR", + "statistics_unit_of_measurement": "EUR", }, ]