From e98ec38ad828280a45d54df3e5dff111a280f597 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ludovic=20BOU=C3=89?= Date: Mon, 23 Jun 2025 17:26:27 +0200 Subject: [PATCH 01/30] Matter energy optimization opt-out attribute (#147096) * ESAStateEnum * Update snapshot * Add test * Update homeassistant/components/matter/strings.json Co-authored-by: Norbert Rittel * Update homeassistant/components/matter/strings.json Co-authored-by: Norbert Rittel * Update homeassistant/components/matter/icons.json Co-authored-by: Martin Hjelmare * Update homeassistant/components/matter/sensor.py Co-authored-by: Martin Hjelmare * Update homeassistant/components/matter/strings.json Co-authored-by: Martin Hjelmare * Update sensor.py * Update snapshot --------- Co-authored-by: Norbert Rittel Co-authored-by: Martin Hjelmare --- homeassistant/components/matter/icons.json | 3 + homeassistant/components/matter/sensor.py | 20 ++ homeassistant/components/matter/strings.json | 9 + .../matter/snapshots/test_sensor.ambr | 186 ++++++++++++++++++ tests/components/matter/test_sensor.py | 12 ++ 5 files changed, 230 insertions(+) diff --git a/homeassistant/components/matter/icons.json b/homeassistant/components/matter/icons.json index 2d7e28888962ed..32f822414aa8fc 100644 --- a/homeassistant/components/matter/icons.json +++ b/homeassistant/components/matter/icons.json @@ -93,6 +93,9 @@ "battery_time_to_full_charge": { "default": "mdi:battery-clock" }, + "esa_opt_out_state": { + "default": "mdi:home-lightning-bolt" + }, "evse_state": { "default": "mdi:ev-station" }, diff --git a/homeassistant/components/matter/sensor.py b/homeassistant/components/matter/sensor.py index 0eefb536bcffc0..0b4d3cc33305cd 100644 --- a/homeassistant/components/matter/sensor.py +++ b/homeassistant/components/matter/sensor.py @@ -93,6 +93,13 @@ clusters.PowerSource.Enums.BatChargeStateEnum.kUnknownEnumValue: None, } +DEM_OPT_OUT_STATE_MAP = { + clusters.DeviceEnergyManagement.Enums.OptOutStateEnum.kNoOptOut: "no_opt_out", + clusters.DeviceEnergyManagement.Enums.OptOutStateEnum.kLocalOptOut: "local_opt_out", + clusters.DeviceEnergyManagement.Enums.OptOutStateEnum.kGridOptOut: "grid_opt_out", + clusters.DeviceEnergyManagement.Enums.OptOutStateEnum.kOptOut: "opt_out", +} + ESA_STATE_MAP = { clusters.DeviceEnergyManagement.Enums.ESAStateEnum.kOffline: "offline", clusters.DeviceEnergyManagement.Enums.ESAStateEnum.kOnline: "online", @@ -1159,6 +1166,19 @@ def _update_from_device(self) -> None: entity_class=MatterSensor, required_attributes=(clusters.DeviceEnergyManagement.Attributes.ESAState,), ), + MatterDiscoverySchema( + platform=Platform.SENSOR, + entity_description=MatterSensorEntityDescription( + key="ESAOptOutState", + translation_key="esa_opt_out_state", + device_class=SensorDeviceClass.ENUM, + entity_category=EntityCategory.DIAGNOSTIC, + options=list(DEM_OPT_OUT_STATE_MAP.values()), + measurement_to_ha=DEM_OPT_OUT_STATE_MAP.get, + ), + entity_class=MatterSensor, + required_attributes=(clusters.DeviceEnergyManagement.Attributes.OptOutState,), + ), MatterDiscoverySchema( platform=Platform.SENSOR, entity_description=MatterSensorEntityDescription( diff --git a/homeassistant/components/matter/strings.json b/homeassistant/components/matter/strings.json index c713dfba615d6c..35a9daa23706ea 100644 --- a/homeassistant/components/matter/strings.json +++ b/homeassistant/components/matter/strings.json @@ -363,6 +363,15 @@ "paused": "[%key:common::state::paused%]" } }, + "esa_opt_out_state": { + "name": "Energy optimization opt-out", + "state": { + "no_opt_out": "[%key:common::state::off%]", + "local_opt_out": "Local", + "grid_opt_out": "Grid", + "opt_out": "Local and grid" + } + }, "evse_fault_state": { "name": "Fault state", "state": { diff --git a/tests/components/matter/snapshots/test_sensor.ambr b/tests/components/matter/snapshots/test_sensor.ambr index 7de836b7092a24..17841121445ea7 100644 --- a/tests/components/matter/snapshots/test_sensor.ambr +++ b/tests/components/matter/snapshots/test_sensor.ambr @@ -1486,6 +1486,68 @@ 'state': '0.0', }) # --- +# name: test_sensors[battery_storage][sensor.mock_battery_storage_energy_optimization_opt_out-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + 'no_opt_out', + 'local_opt_out', + 'grid_opt_out', + 'opt_out', + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.mock_battery_storage_energy_optimization_opt_out', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Energy optimization opt-out', + 'platform': 'matter', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'esa_opt_out_state', + 'unique_id': '00000000000004D2-0000000000000019-MatterNodeDevice-1-ESAOptOutState-152-7', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensors[battery_storage][sensor.mock_battery_storage_energy_optimization_opt_out-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Mock Battery Storage Energy optimization opt-out', + 'options': list([ + 'no_opt_out', + 'local_opt_out', + 'grid_opt_out', + 'opt_out', + ]), + }), + 'context': , + 'entity_id': 'sensor.mock_battery_storage_energy_optimization_opt_out', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'no_opt_out', + }) +# --- # name: test_sensors[battery_storage][sensor.mock_battery_storage_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ @@ -4645,6 +4707,68 @@ 'state': '32.0', }) # --- +# name: test_sensors[silabs_evse_charging][sensor.evse_energy_optimization_opt_out-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + 'no_opt_out', + 'local_opt_out', + 'grid_opt_out', + 'opt_out', + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.evse_energy_optimization_opt_out', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Energy optimization opt-out', + 'platform': 'matter', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'esa_opt_out_state', + 'unique_id': '00000000000004D2-0000000000000017-MatterNodeDevice-1-ESAOptOutState-152-7', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensors[silabs_evse_charging][sensor.evse_energy_optimization_opt_out-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'evse Energy optimization opt-out', + 'options': list([ + 'no_opt_out', + 'local_opt_out', + 'grid_opt_out', + 'opt_out', + ]), + }), + 'context': , + 'entity_id': 'sensor.evse_energy_optimization_opt_out', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'no_opt_out', + }) +# --- # name: test_sensors[silabs_evse_charging][sensor.evse_fault_state-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ @@ -5389,6 +5513,68 @@ 'state': '0.1', }) # --- +# name: test_sensors[silabs_water_heater][sensor.water_heater_energy_optimization_opt_out-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + 'no_opt_out', + 'local_opt_out', + 'grid_opt_out', + 'opt_out', + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.water_heater_energy_optimization_opt_out', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Energy optimization opt-out', + 'platform': 'matter', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'esa_opt_out_state', + 'unique_id': '00000000000004D2-0000000000000019-MatterNodeDevice-2-ESAOptOutState-152-7', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensors[silabs_water_heater][sensor.water_heater_energy_optimization_opt_out-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Water Heater Energy optimization opt-out', + 'options': list([ + 'no_opt_out', + 'local_opt_out', + 'grid_opt_out', + 'opt_out', + ]), + }), + 'context': , + 'entity_id': 'sensor.water_heater_energy_optimization_opt_out', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'no_opt_out', + }) +# --- # name: test_sensors[silabs_water_heater][sensor.water_heater_hot_water_level-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ diff --git a/tests/components/matter/test_sensor.py b/tests/components/matter/test_sensor.py index e70101bf80422e..3e9af4a6e4b55d 100644 --- a/tests/components/matter/test_sensor.py +++ b/tests/components/matter/test_sensor.py @@ -524,6 +524,18 @@ async def test_water_heater( assert state assert state.state == "offline" + # DeviceEnergyManagement -> OptOutState attribute + state = hass.states.get("sensor.water_heater_energy_optimization_opt_out") + assert state + assert state.state == "no_opt_out" + + set_node_attribute(matter_node, 2, 152, 7, 3) + await trigger_subscription_callback(hass, matter_client) + + state = hass.states.get("sensor.water_heater_energy_optimization_opt_out") + assert state + assert state.state == "opt_out" + @pytest.mark.parametrize("node_fixture", ["pump"]) async def test_pump( From ccbc5ed65b553a94f8bffb7882a871da9e354954 Mon Sep 17 00:00:00 2001 From: "J. Nick Koston" Date: Mon, 23 Jun 2025 17:50:56 +0200 Subject: [PATCH 02/30] Bump aioesphomeapi to 3.1.1 (#147345) --- homeassistant/components/esphome/manifest.json | 2 +- requirements_all.txt | 2 +- requirements_test_all.txt | 2 +- tests/components/esphome/snapshots/test_diagnostics.ambr | 8 ++++++++ tests/components/esphome/test_diagnostics.py | 3 +++ 5 files changed, 14 insertions(+), 3 deletions(-) diff --git a/homeassistant/components/esphome/manifest.json b/homeassistant/components/esphome/manifest.json index 0577ed10c19a80..68bc8fe040e59a 100644 --- a/homeassistant/components/esphome/manifest.json +++ b/homeassistant/components/esphome/manifest.json @@ -17,7 +17,7 @@ "mqtt": ["esphome/discover/#"], "quality_scale": "platinum", "requirements": [ - "aioesphomeapi==33.0.0", + "aioesphomeapi==33.1.1", "esphome-dashboard-api==1.3.0", "bleak-esphome==2.16.0" ], diff --git a/requirements_all.txt b/requirements_all.txt index 8d8817102cd03c..f76d831c5fed98 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -244,7 +244,7 @@ aioelectricitymaps==0.4.0 aioemonitor==1.0.5 # homeassistant.components.esphome -aioesphomeapi==33.0.0 +aioesphomeapi==33.1.1 # homeassistant.components.flo aioflo==2021.11.0 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index b53a6779b4e5ca..ec9d8b973b62df 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -232,7 +232,7 @@ aioelectricitymaps==0.4.0 aioemonitor==1.0.5 # homeassistant.components.esphome -aioesphomeapi==33.0.0 +aioesphomeapi==33.1.1 # homeassistant.components.flo aioflo==2021.11.0 diff --git a/tests/components/esphome/snapshots/test_diagnostics.ambr b/tests/components/esphome/snapshots/test_diagnostics.ambr index d88f2045e560f1..dac224c802f627 100644 --- a/tests/components/esphome/snapshots/test_diagnostics.ambr +++ b/tests/components/esphome/snapshots/test_diagnostics.ambr @@ -82,9 +82,17 @@ 'minor': 99, }), 'device_info': dict({ + 'area': dict({ + 'area_id': 0, + 'name': '', + }), + 'areas': list([ + ]), 'bluetooth_mac_address': '', 'bluetooth_proxy_feature_flags': 0, 'compilation_time': '', + 'devices': list([ + ]), 'esphome_version': '1.0.0', 'friendly_name': 'Test', 'has_deep_sleep': False, diff --git a/tests/components/esphome/test_diagnostics.py b/tests/components/esphome/test_diagnostics.py index 8f1843900d791e..2653df57adb708 100644 --- a/tests/components/esphome/test_diagnostics.py +++ b/tests/components/esphome/test_diagnostics.py @@ -124,9 +124,12 @@ async def test_diagnostics_with_bluetooth( "storage_data": { "api_version": {"major": 99, "minor": 99}, "device_info": { + "area": {"area_id": 0, "name": ""}, + "areas": [], "bluetooth_mac_address": "**REDACTED**", "bluetooth_proxy_feature_flags": 63, "compilation_time": "", + "devices": [], "esphome_version": "1.0.0", "friendly_name": "Test", "has_deep_sleep": False, From 7bb9936e81c6e804975dcb7aea84bd3e9d3a5f74 Mon Sep 17 00:00:00 2001 From: Foscam-wangzhengyu Date: Tue, 24 Jun 2025 00:10:31 +0800 Subject: [PATCH 03/30] Replace foscam dependency (#145766) * Update Public Library * Update conftest.py --- homeassistant/components/foscam/__init__.py | 2 +- homeassistant/components/foscam/config_flow.py | 4 ++-- homeassistant/components/foscam/coordinator.py | 2 +- homeassistant/components/foscam/manifest.json | 4 ++-- requirements_all.txt | 2 +- requirements_test_all.txt | 2 +- tests/components/foscam/conftest.py | 2 +- 7 files changed, 9 insertions(+), 9 deletions(-) diff --git a/homeassistant/components/foscam/__init__.py b/homeassistant/components/foscam/__init__.py index 9643f333bb565c..222a7e44a45613 100644 --- a/homeassistant/components/foscam/__init__.py +++ b/homeassistant/components/foscam/__init__.py @@ -1,6 +1,6 @@ """The foscam component.""" -from libpyfoscam import FoscamCamera +from libpyfoscamcgi import FoscamCamera from homeassistant.const import ( CONF_HOST, diff --git a/homeassistant/components/foscam/config_flow.py b/homeassistant/components/foscam/config_flow.py index 19c19a1a5f5bcc..562c3f42f8b210 100644 --- a/homeassistant/components/foscam/config_flow.py +++ b/homeassistant/components/foscam/config_flow.py @@ -2,8 +2,8 @@ from typing import Any -from libpyfoscam import FoscamCamera -from libpyfoscam.foscam import ( +from libpyfoscamcgi import FoscamCamera +from libpyfoscamcgi.foscamcgi import ( ERROR_FOSCAM_AUTH, ERROR_FOSCAM_UNAVAILABLE, FOSCAM_SUCCESS, diff --git a/homeassistant/components/foscam/coordinator.py b/homeassistant/components/foscam/coordinator.py index 92eb7615e2a1b5..72bf60cffe01a8 100644 --- a/homeassistant/components/foscam/coordinator.py +++ b/homeassistant/components/foscam/coordinator.py @@ -4,7 +4,7 @@ from datetime import timedelta from typing import Any -from libpyfoscam import FoscamCamera +from libpyfoscamcgi import FoscamCamera from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant diff --git a/homeassistant/components/foscam/manifest.json b/homeassistant/components/foscam/manifest.json index 9ddb7c4b4fc732..9e6864cf1c69ad 100644 --- a/homeassistant/components/foscam/manifest.json +++ b/homeassistant/components/foscam/manifest.json @@ -5,6 +5,6 @@ "config_flow": true, "documentation": "https://www.home-assistant.io/integrations/foscam", "iot_class": "local_polling", - "loggers": ["libpyfoscam"], - "requirements": ["libpyfoscam==1.2.2"] + "loggers": ["libpyfoscamcgi"], + "requirements": ["libpyfoscamcgi==0.0.6"] } diff --git a/requirements_all.txt b/requirements_all.txt index f76d831c5fed98..8e35b3f0f7c5e5 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -1337,7 +1337,7 @@ lektricowifi==0.1 letpot==0.4.0 # homeassistant.components.foscam -libpyfoscam==1.2.2 +libpyfoscamcgi==0.0.6 # homeassistant.components.vivotek libpyvivotek==0.4.0 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index ec9d8b973b62df..409e1bc19e20a2 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -1153,7 +1153,7 @@ lektricowifi==0.1 letpot==0.4.0 # homeassistant.components.foscam -libpyfoscam==1.2.2 +libpyfoscamcgi==0.0.6 # homeassistant.components.mikrotik librouteros==3.2.0 diff --git a/tests/components/foscam/conftest.py b/tests/components/foscam/conftest.py index 6ff5a0b5af5b2b..f8b4093574fd0e 100644 --- a/tests/components/foscam/conftest.py +++ b/tests/components/foscam/conftest.py @@ -1,6 +1,6 @@ """Common stuff for Foscam tests.""" -from libpyfoscam.foscam import ( +from libpyfoscamcgi.foscamcgi import ( ERROR_FOSCAM_AUTH, ERROR_FOSCAM_CMD, ERROR_FOSCAM_UNAVAILABLE, From 7eaa60b17c3b4aced1b8905a5c5525748f2c9c7a Mon Sep 17 00:00:00 2001 From: Petro31 <35082313+Petro31@users.noreply.github.com> Date: Mon, 23 Jun 2025 12:10:44 -0400 Subject: [PATCH 04/30] Add trigger vacuum entities to template integration (#145534) * Add trigger vacuum entities to template integration * remove comment --------- Co-authored-by: Erik Montnemery --- homeassistant/components/template/config.py | 1 - homeassistant/components/template/vacuum.py | 82 ++++++- tests/components/template/test_vacuum.py | 253 +++++++++++++++++--- 3 files changed, 290 insertions(+), 46 deletions(-) diff --git a/homeassistant/components/template/config.py b/homeassistant/components/template/config.py index 1e1a27e26c6de3..a5aa9a3bd87dfd 100644 --- a/homeassistant/components/template/config.py +++ b/homeassistant/components/template/config.py @@ -159,7 +159,6 @@ def _backward_compat_schema(value: Any | None) -> Any: ensure_domains_do_not_have_trigger_or_action( DOMAIN_BUTTON, DOMAIN_FAN, - DOMAIN_VACUUM, ), ) diff --git a/homeassistant/components/template/vacuum.py b/homeassistant/components/template/vacuum.py index 79e00e7e1c09c4..1fb5b89ead270a 100644 --- a/homeassistant/components/template/vacuum.py +++ b/homeassistant/components/template/vacuum.py @@ -39,6 +39,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType from .const import CONF_OBJECT_ID, DOMAIN +from .coordinator import TriggerUpdateCoordinator from .entity import AbstractTemplateEntity from .template_entity import ( LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS, @@ -48,6 +49,7 @@ make_template_entity_common_modern_attributes_schema, rewrite_common_legacy_to_modern_conf, ) +from .trigger_entity import TriggerEntity _LOGGER = logging.getLogger(__name__) @@ -187,6 +189,13 @@ async def async_setup_platform( ) return + if "coordinator" in discovery_info: + async_add_entities( + TriggerVacuumEntity(hass, discovery_info["coordinator"], config) + for config in discovery_info["entities"] + ) + return + _async_create_template_tracking_entities( async_add_entities, hass, @@ -213,7 +222,14 @@ def __init__(self, config: dict[str, Any]) -> None: # pylint: disable=super-ini # List of valid fan speeds self._attr_fan_speed_list = config[CONF_FAN_SPEED_LIST] - def _register_scripts( + self._attr_supported_features = ( + VacuumEntityFeature.START | VacuumEntityFeature.STATE + ) + + if self._battery_level_template: + self._attr_supported_features |= VacuumEntityFeature.BATTERY + + def _iterate_scripts( self, config: dict[str, Any] ) -> Generator[tuple[str, Sequence[dict[str, Any]], VacuumEntityFeature | int]]: for action_id, supported_feature in ( @@ -356,18 +372,12 @@ def __init__( if TYPE_CHECKING: assert name is not None - self._attr_supported_features = ( - VacuumEntityFeature.START | VacuumEntityFeature.STATE - ) - for action_id, action_config, supported_feature in self._register_scripts( + for action_id, action_config, supported_feature in self._iterate_scripts( config ): self.add_script(action_id, action_config, name, DOMAIN) self._attr_supported_features |= supported_feature - if self._battery_level_template: - self._attr_supported_features |= VacuumEntityFeature.BATTERY - @callback def _async_setup_templates(self) -> None: """Set up templates.""" @@ -403,3 +413,59 @@ def _update_state(self, result): return self._handle_state(result) + + +class TriggerVacuumEntity(TriggerEntity, AbstractTemplateVacuum): + """Vacuum entity based on trigger data.""" + + domain = VACUUM_DOMAIN + + def __init__( + self, + hass: HomeAssistant, + coordinator: TriggerUpdateCoordinator, + config: ConfigType, + ) -> None: + """Initialize the entity.""" + TriggerEntity.__init__(self, hass, coordinator, config) + AbstractTemplateVacuum.__init__(self, config) + + self._attr_name = name = self._rendered.get(CONF_NAME, DEFAULT_NAME) + + for action_id, action_config, supported_feature in self._iterate_scripts( + config + ): + self.add_script(action_id, action_config, name, DOMAIN) + self._attr_supported_features |= supported_feature + + for key in (CONF_STATE, CONF_FAN_SPEED, CONF_BATTERY_LEVEL): + if isinstance(config.get(key), template.Template): + self._to_render_simple.append(key) + self._parse_result.add(key) + + @callback + def _handle_coordinator_update(self) -> None: + """Handle update of the data.""" + self._process_data() + + if not self.available: + self.async_write_ha_state() + return + + write_ha_state = False + for key, updater in ( + (CONF_STATE, self._handle_state), + (CONF_FAN_SPEED, self._update_fan_speed), + (CONF_BATTERY_LEVEL, self._update_battery_level), + ): + if (rendered := self._rendered.get(key)) is not None: + updater(rendered) + write_ha_state = True + + if len(self._rendered) > 0: + # In case any non optimistic template + write_ha_state = True + + if write_ha_state: + self.async_set_context(self.coordinator.data["context"]) + self.async_write_ha_state() diff --git a/tests/components/template/test_vacuum.py b/tests/components/template/test_vacuum.py index 90ca0b56afbb5c..ae65823309a5ae 100644 --- a/tests/components/template/test_vacuum.py +++ b/tests/components/template/test_vacuum.py @@ -26,8 +26,26 @@ TEST_OBJECT_ID = "test_vacuum" TEST_ENTITY_ID = f"vacuum.{TEST_OBJECT_ID}" -STATE_INPUT_SELECT = "input_select.state" -BATTERY_LEVEL_INPUT_NUMBER = "input_number.battery_level" +TEST_STATE_SENSOR = "sensor.test_state" +TEST_SPEED_SENSOR = "sensor.test_fan_speed" +TEST_BATTERY_LEVEL_SENSOR = "sensor.test_battery_level" +TEST_AVAILABILITY_ENTITY = "availability_state.state" + +TEST_STATE_TRIGGER = { + "trigger": { + "trigger": "state", + "entity_id": [ + TEST_STATE_SENSOR, + TEST_SPEED_SENSOR, + TEST_BATTERY_LEVEL_SENSOR, + TEST_AVAILABILITY_ENTITY, + ], + }, + "variables": {"triggering_entity": "{{ trigger.entity_id }}"}, + "action": [ + {"event": "action_event", "event_data": {"what": "{{ triggering_entity }}"}} + ], +} START_ACTION = { "start": { @@ -140,6 +158,24 @@ async def async_setup_modern_format( await hass.async_block_till_done() +async def async_setup_trigger_format( + hass: HomeAssistant, count: int, vacuum_config: dict[str, Any] +) -> None: + """Do setup of vacuum integration via trigger format.""" + config = {"template": {"vacuum": vacuum_config, **TEST_STATE_TRIGGER}} + + with assert_setup_component(count, template.DOMAIN): + assert await async_setup_component( + hass, + template.DOMAIN, + config, + ) + + await hass.async_block_till_done() + await hass.async_start() + await hass.async_block_till_done() + + @pytest.fixture async def setup_vacuum( hass: HomeAssistant, @@ -152,6 +188,8 @@ async def setup_vacuum( await async_setup_legacy_format(hass, count, vacuum_config) elif style == ConfigurationStyle.MODERN: await async_setup_modern_format(hass, count, vacuum_config) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format(hass, count, vacuum_config) @pytest.fixture @@ -171,6 +209,10 @@ async def setup_test_vacuum_with_extra_config( await async_setup_modern_format( hass, count, {"name": TEST_OBJECT_ID, **vacuum_config, **extra_config} ) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format( + hass, count, {"name": TEST_OBJECT_ID, **vacuum_config, **extra_config} + ) @pytest.fixture @@ -202,6 +244,16 @@ async def setup_state_vacuum( **TEMPLATE_VACUUM_ACTIONS, }, ) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + "state": state_template, + **TEMPLATE_VACUUM_ACTIONS, + }, + ) @pytest.fixture @@ -236,6 +288,17 @@ async def setup_base_vacuum( **extra_config, }, ) + elif style == ConfigurationStyle.TRIGGER: + state_config = {"state": state_template} if state_template else {} + await async_setup_trigger_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + **state_config, + **extra_config, + }, + ) @pytest.fixture @@ -277,6 +340,19 @@ async def setup_single_attribute_state_vacuum( **extra_config, }, ) + elif style == ConfigurationStyle.TRIGGER: + state_config = {"state": state_template} if state_template else {} + await async_setup_trigger_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + **state_config, + **TEMPLATE_VACUUM_ACTIONS, + **extra, + **extra_config, + }, + ) @pytest.fixture @@ -313,6 +389,18 @@ async def setup_attributes_state_vacuum( **TEMPLATE_VACUUM_ACTIONS, }, ) + elif style == ConfigurationStyle.TRIGGER: + state_config = {"state": state_template} if state_template else {} + await async_setup_trigger_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + "attributes": attributes, + **state_config, + **TEMPLATE_VACUUM_ACTIONS, + }, + ) @pytest.mark.parametrize("count", [1]) @@ -333,6 +421,13 @@ async def setup_attributes_state_vacuum( STATE_UNKNOWN, None, ), + ( + ConfigurationStyle.TRIGGER, + None, + {"start": {"service": "script.vacuum_start"}}, + STATE_UNKNOWN, + None, + ), ( ConfigurationStyle.LEGACY, "{{ 'cleaning' }}", @@ -353,6 +448,16 @@ async def setup_attributes_state_vacuum( VacuumActivity.CLEANING, 100, ), + ( + ConfigurationStyle.TRIGGER, + "{{ 'cleaning' }}", + { + "battery_level": "{{ 100 }}", + "start": {"service": "script.vacuum_start"}, + }, + VacuumActivity.CLEANING, + 100, + ), ( ConfigurationStyle.LEGACY, "{{ 'abc' }}", @@ -373,6 +478,16 @@ async def setup_attributes_state_vacuum( STATE_UNKNOWN, None, ), + ( + ConfigurationStyle.TRIGGER, + "{{ 'abc' }}", + { + "battery_level": "{{ 101 }}", + "start": {"service": "script.vacuum_start"}, + }, + STATE_UNKNOWN, + None, + ), ( ConfigurationStyle.LEGACY, "{{ this_function_does_not_exist() }}", @@ -395,18 +510,35 @@ async def setup_attributes_state_vacuum( STATE_UNKNOWN, None, ), + ( + ConfigurationStyle.TRIGGER, + "{{ this_function_does_not_exist() }}", + { + "battery_level": "{{ this_function_does_not_exist() }}", + "fan_speed": "{{ this_function_does_not_exist() }}", + "start": {"service": "script.vacuum_start"}, + }, + STATE_UNAVAILABLE, + None, + ), ], ) @pytest.mark.usefixtures("setup_base_vacuum") async def test_valid_legacy_configs(hass: HomeAssistant, count, parm1, parm2) -> None: """Test: configs.""" + + # Ensure trigger entity templates are rendered + hass.states.async_set(TEST_STATE_SENSOR, None) + await hass.async_block_till_done() + assert len(hass.states.async_all("vacuum")) == count _verify(hass, parm1, parm2) @pytest.mark.parametrize("count", [0]) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( ("state_template", "extra_config"), @@ -423,13 +555,14 @@ async def test_invalid_configs(hass: HomeAssistant, count) -> None: @pytest.mark.parametrize( ("count", "state_template", "extra_config"), - [(1, "{{ states('input_select.state') }}", {})], + [(1, "{{ states('sensor.test_state') }}", {})], ) @pytest.mark.parametrize( ("style", "attribute"), [ (ConfigurationStyle.LEGACY, "battery_level_template"), (ConfigurationStyle.MODERN, "battery_level"), + (ConfigurationStyle.TRIGGER, "battery_level"), ], ) @pytest.mark.parametrize( @@ -447,6 +580,10 @@ async def test_battery_level_template( hass: HomeAssistant, expected: int | None ) -> None: """Test templates with values from other entities.""" + # Ensure trigger entity templates are rendered + hass.states.async_set(TEST_STATE_SENSOR, None) + await hass.async_block_till_done() + _verify(hass, STATE_UNKNOWN, expected) @@ -455,7 +592,7 @@ async def test_battery_level_template( [ ( 1, - "{{ states('input_select.state') }}", + "{{ states('sensor.test_state') }}", { "fan_speeds": ["low", "medium", "high"], }, @@ -467,6 +604,7 @@ async def test_battery_level_template( [ (ConfigurationStyle.LEGACY, "fan_speed_template"), (ConfigurationStyle.MODERN, "fan_speed"), + (ConfigurationStyle.TRIGGER, "fan_speed"), ], ) @pytest.mark.parametrize( @@ -481,33 +619,39 @@ async def test_battery_level_template( @pytest.mark.usefixtures("setup_single_attribute_state_vacuum") async def test_fan_speed_template(hass: HomeAssistant, expected: str | None) -> None: """Test templates with values from other entities.""" + # Ensure trigger entity templates are rendered + hass.states.async_set(TEST_STATE_SENSOR, None) + await hass.async_block_till_done() + _verify(hass, STATE_UNKNOWN, None, expected) @pytest.mark.parametrize( - ("count", "state_template", "attribute_template", "extra_config"), + ("count", "state_template", "attribute_template", "extra_config", "attribute"), [ ( 1, "{{ 'on' }}", - "{% if states.switch.test_state.state %}mdi:check{% endif %}", + "{% if states.sensor.test_state.state %}mdi:check{% endif %}", {}, + "icon", ) ], ) @pytest.mark.parametrize( - ("style", "attribute"), + ("style", "expected"), [ - (ConfigurationStyle.MODERN, "icon"), + (ConfigurationStyle.MODERN, ""), + (ConfigurationStyle.TRIGGER, None), ], ) @pytest.mark.usefixtures("setup_single_attribute_state_vacuum") -async def test_icon_template(hass: HomeAssistant) -> None: +async def test_icon_template(hass: HomeAssistant, expected: int) -> None: """Test icon template.""" state = hass.states.get(TEST_ENTITY_ID) - assert state.attributes.get("icon") in ("", None) + assert state.attributes.get("icon") == expected - hass.states.async_set("switch.test_state", STATE_ON) + hass.states.async_set(TEST_STATE_SENSOR, STATE_ON) await hass.async_block_till_done() state = hass.states.get(TEST_ENTITY_ID) @@ -515,29 +659,31 @@ async def test_icon_template(hass: HomeAssistant) -> None: @pytest.mark.parametrize( - ("count", "state_template", "attribute_template", "extra_config"), + ("count", "state_template", "attribute_template", "extra_config", "attribute"), [ ( 1, "{{ 'on' }}", - "{% if states.switch.test_state.state %}local/vacuum.png{% endif %}", + "{% if states.sensor.test_state.state %}local/vacuum.png{% endif %}", {}, + "picture", ) ], ) @pytest.mark.parametrize( - ("style", "attribute"), + ("style", "expected"), [ - (ConfigurationStyle.MODERN, "picture"), + (ConfigurationStyle.MODERN, ""), + (ConfigurationStyle.TRIGGER, None), ], ) @pytest.mark.usefixtures("setup_single_attribute_state_vacuum") -async def test_picture_template(hass: HomeAssistant) -> None: +async def test_picture_template(hass: HomeAssistant, expected: int) -> None: """Test picture template.""" state = hass.states.get(TEST_ENTITY_ID) - assert state.attributes.get("entity_picture") in ("", None) + assert state.attributes.get("entity_picture") == expected - hass.states.async_set("switch.test_state", STATE_ON) + hass.states.async_set(TEST_STATE_SENSOR, STATE_ON) await hass.async_block_till_done() state = hass.states.get(TEST_ENTITY_ID) @@ -560,6 +706,7 @@ async def test_picture_template(hass: HomeAssistant) -> None: [ (ConfigurationStyle.LEGACY, "availability_template"), (ConfigurationStyle.MODERN, "availability"), + (ConfigurationStyle.TRIGGER, "availability"), ], ) @pytest.mark.usefixtures("setup_single_attribute_state_vacuum") @@ -567,14 +714,14 @@ async def test_available_template_with_entities(hass: HomeAssistant) -> None: """Test availability templates with values from other entities.""" # When template returns true.. - hass.states.async_set("availability_state.state", STATE_ON) + hass.states.async_set(TEST_AVAILABILITY_ENTITY, STATE_ON) await hass.async_block_till_done() # Device State should not be unavailable assert hass.states.get(TEST_ENTITY_ID).state != STATE_UNAVAILABLE # When Availability template returns false - hass.states.async_set("availability_state.state", STATE_OFF) + hass.states.async_set(TEST_AVAILABILITY_ENTITY, STATE_OFF) await hass.async_block_till_done() # device state should be unavailable @@ -597,15 +744,22 @@ async def test_available_template_with_entities(hass: HomeAssistant) -> None: [ (ConfigurationStyle.LEGACY, "availability_template"), (ConfigurationStyle.MODERN, "availability"), + (ConfigurationStyle.TRIGGER, "availability"), ], ) @pytest.mark.usefixtures("setup_single_attribute_state_vacuum") async def test_invalid_availability_template_keeps_component_available( - hass: HomeAssistant, caplog_setup_text + hass: HomeAssistant, caplog_setup_text, caplog: pytest.LogCaptureFixture ) -> None: """Test that an invalid availability keeps the device available.""" + + # Ensure state change triggers trigger entity. + hass.states.async_set(TEST_STATE_SENSOR, None) + await hass.async_block_till_done() + assert hass.states.get(TEST_ENTITY_ID) != STATE_UNAVAILABLE - assert "UndefinedError: 'x' is undefined" in caplog_setup_text + err = "'x' is undefined" + assert err in caplog_setup_text or err in caplog.text @pytest.mark.parametrize( @@ -627,7 +781,7 @@ async def test_attribute_templates(hass: HomeAssistant) -> None: state = hass.states.get(TEST_ENTITY_ID) assert state.attributes["test_attribute"] == "It ." - hass.states.async_set("sensor.test_state", "Works") + hass.states.async_set(TEST_STATE_SENSOR, "Works") await hass.async_block_till_done() await async_update_entity(hass, TEST_ENTITY_ID) state = hass.states.get(TEST_ENTITY_ID) @@ -635,26 +789,31 @@ async def test_attribute_templates(hass: HomeAssistant) -> None: @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( ("count", "state_template", "attributes"), [ ( 1, - "{{ states('input_select.state') }}", + "{{ states('sensor.test_state') }}", {"test_attribute": "{{ this_function_does_not_exist() }}"}, ) ], ) @pytest.mark.usefixtures("setup_attributes_state_vacuum") async def test_invalid_attribute_template( - hass: HomeAssistant, caplog_setup_text + hass: HomeAssistant, caplog_setup_text, caplog: pytest.LogCaptureFixture ) -> None: """Test that errors are logged if rendering template fails.""" + + hass.states.async_set(TEST_STATE_SENSOR, "Works") + await hass.async_block_till_done() + assert len(hass.states.async_all("vacuum")) == 1 - assert "test_attribute" in caplog_setup_text - assert "TemplateError" in caplog_setup_text + err = "'this_function_does_not_exist' is undefined" + assert err in caplog_setup_text or err in caplog.text @pytest.mark.parametrize("count", [1]) @@ -689,6 +848,21 @@ async def test_invalid_attribute_template( }, ], ), + ( + ConfigurationStyle.TRIGGER, + [ + { + "name": "test_template_vacuum_01", + "state": "{{ true }}", + **UNIQUE_ID_CONFIG, + }, + { + "name": "test_template_vacuum_02", + "state": "{{ false }}", + **UNIQUE_ID_CONFIG, + }, + ], + ), ], ) @pytest.mark.usefixtures("setup_vacuum") @@ -701,7 +875,8 @@ async def test_unique_id(hass: HomeAssistant) -> None: ("count", "state_template", "extra_config"), [(1, None, START_ACTION)] ) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_base_vacuum") async def test_unused_services(hass: HomeAssistant) -> None: @@ -741,10 +916,11 @@ async def test_unused_services(hass: HomeAssistant) -> None: @pytest.mark.parametrize( ("count", "state_template"), - [(1, "{{ states('input_select.state') }}")], + [(1, "{{ states('sensor.test_state') }}")], ) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( "action", @@ -782,8 +958,8 @@ async def test_state_services( [ ( 1, - "{{ states('input_select.state') }}", - "{{ states('input_select.fan_speed') }}", + "{{ states('sensor.test_state') }}", + "{{ states('sensor.test_fan_speed') }}", { "fan_speeds": ["low", "medium", "high"], }, @@ -795,6 +971,7 @@ async def test_state_services( [ (ConfigurationStyle.LEGACY, "fan_speed_template"), (ConfigurationStyle.MODERN, "fan_speed"), + (ConfigurationStyle.TRIGGER, "fan_speed"), ], ) @pytest.mark.usefixtures("setup_single_attribute_state_vacuum") @@ -835,8 +1012,8 @@ async def test_set_fan_speed(hass: HomeAssistant, calls: list[ServiceCall]) -> N [ ( 1, - "{{ states('input_select.state') }}", - "{{ states('input_select.fan_speed') }}", + "{{ states('sensor.test_state') }}", + "{{ states('sensor.test_fan_speed') }}", ) ], ) @@ -845,6 +1022,7 @@ async def test_set_fan_speed(hass: HomeAssistant, calls: list[ServiceCall]) -> N [ (ConfigurationStyle.LEGACY, "fan_speed_template"), (ConfigurationStyle.MODERN, "fan_speed"), + (ConfigurationStyle.TRIGGER, "fan_speed"), ], ) @pytest.mark.usefixtures("setup_single_attribute_state_vacuum") @@ -918,7 +1096,8 @@ async def test_nested_unique_id( @pytest.mark.parametrize(("count", "vacuum_config"), [(1, {"start": []})]) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( ("extra_config", "supported_features"), From 27565df86f97b2201ed1bcb9c04251d2bfd1a048 Mon Sep 17 00:00:00 2001 From: Andre Lengwenus Date: Mon, 23 Jun 2025 19:08:18 +0200 Subject: [PATCH 05/30] Add PARALLEL_UPDATES constant to binary_sensor and sensor for LCN (#147369) Add PARALLEL_UPDATES to binary_sensor and sensor --- homeassistant/components/lcn/binary_sensor.py | 2 ++ homeassistant/components/lcn/sensor.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/homeassistant/components/lcn/binary_sensor.py b/homeassistant/components/lcn/binary_sensor.py index d8418c6d838cb0..b124b3f6188abf 100644 --- a/homeassistant/components/lcn/binary_sensor.py +++ b/homeassistant/components/lcn/binary_sensor.py @@ -25,6 +25,8 @@ from .entity import LcnEntity from .helpers import InputType, LcnConfigEntry +PARALLEL_UPDATES = 0 + def add_lcn_entities( config_entry: LcnConfigEntry, diff --git a/homeassistant/components/lcn/sensor.py b/homeassistant/components/lcn/sensor.py index fd90c024383207..da475e5000508d 100644 --- a/homeassistant/components/lcn/sensor.py +++ b/homeassistant/components/lcn/sensor.py @@ -38,6 +38,8 @@ from .entity import LcnEntity from .helpers import InputType, LcnConfigEntry +PARALLEL_UPDATES = 0 + DEVICE_CLASS_MAPPING = { pypck.lcn_defs.VarUnit.CELSIUS: SensorDeviceClass.TEMPERATURE, pypck.lcn_defs.VarUnit.KELVIN: SensorDeviceClass.TEMPERATURE, From e1d5d312b82af2a81d290560300c1b98d2a40e8e Mon Sep 17 00:00:00 2001 From: epenet <6771947+epenet@users.noreply.github.com> Date: Mon, 23 Jun 2025 19:08:32 +0200 Subject: [PATCH 06/30] Migrate linear_garage_door to use runtime_data (#147351) Migrate linear_garage_door to use runtime_data/HassKey --- .../components/linear_garage_door/__init__.py | 16 ++++++---------- .../components/linear_garage_door/coordinator.py | 6 ++++-- .../components/linear_garage_door/cover.py | 8 +++----- .../components/linear_garage_door/diagnostics.py | 8 +++----- .../components/linear_garage_door/light.py | 8 +++----- 5 files changed, 19 insertions(+), 27 deletions(-) diff --git a/homeassistant/components/linear_garage_door/__init__.py b/homeassistant/components/linear_garage_door/__init__.py index c2a6c6a7ed1405..a80aa99628b034 100644 --- a/homeassistant/components/linear_garage_door/__init__.py +++ b/homeassistant/components/linear_garage_door/__init__.py @@ -2,18 +2,17 @@ from __future__ import annotations -from homeassistant.config_entries import ConfigEntry from homeassistant.const import Platform from homeassistant.core import HomeAssistant from homeassistant.helpers import issue_registry as ir from .const import DOMAIN -from .coordinator import LinearUpdateCoordinator +from .coordinator import LinearConfigEntry, LinearUpdateCoordinator PLATFORMS: list[Platform] = [Platform.COVER, Platform.LIGHT] -async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: +async def async_setup_entry(hass: HomeAssistant, entry: LinearConfigEntry) -> bool: """Set up Linear Garage Door from a config entry.""" ir.async_create_issue( @@ -35,21 +34,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: await coordinator.async_config_entry_first_refresh() - hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator + entry.runtime_data = coordinator await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) return True -async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: +async def async_unload_entry(hass: HomeAssistant, entry: LinearConfigEntry) -> bool: """Unload a config entry.""" - if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS): - hass.data[DOMAIN].pop(entry.entry_id) + return await hass.config_entries.async_unload_platforms(entry, PLATFORMS) - return unload_ok - -async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None: +async def async_remove_entry(hass: HomeAssistant, entry: LinearConfigEntry) -> None: """Remove a config entry.""" if not hass.config_entries.async_loaded_entries(DOMAIN): ir.async_delete_issue(hass, DOMAIN, DOMAIN) diff --git a/homeassistant/components/linear_garage_door/coordinator.py b/homeassistant/components/linear_garage_door/coordinator.py index b55affe92e71d9..3844e1ae7debc6 100644 --- a/homeassistant/components/linear_garage_door/coordinator.py +++ b/homeassistant/components/linear_garage_door/coordinator.py @@ -19,6 +19,8 @@ _LOGGER = logging.getLogger(__name__) +type LinearConfigEntry = ConfigEntry[LinearUpdateCoordinator] + @dataclass class LinearDevice: @@ -32,9 +34,9 @@ class LinearUpdateCoordinator(DataUpdateCoordinator[dict[str, LinearDevice]]): """DataUpdateCoordinator for Linear.""" _devices: list[dict[str, Any]] | None = None - config_entry: ConfigEntry + config_entry: LinearConfigEntry - def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry) -> None: + def __init__(self, hass: HomeAssistant, config_entry: LinearConfigEntry) -> None: """Initialize DataUpdateCoordinator for Linear.""" super().__init__( hass, diff --git a/homeassistant/components/linear_garage_door/cover.py b/homeassistant/components/linear_garage_door/cover.py index 7b0510f00d1cf8..1f6c09995313cb 100644 --- a/homeassistant/components/linear_garage_door/cover.py +++ b/homeassistant/components/linear_garage_door/cover.py @@ -8,12 +8,10 @@ CoverEntity, CoverEntityFeature, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import DOMAIN -from .coordinator import LinearUpdateCoordinator +from .coordinator import LinearConfigEntry from .entity import LinearEntity SUPPORTED_SUBDEVICES = ["GDO"] @@ -23,11 +21,11 @@ async def async_setup_entry( hass: HomeAssistant, - config_entry: ConfigEntry, + config_entry: LinearConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up Linear Garage Door cover.""" - coordinator: LinearUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id] + coordinator = config_entry.runtime_data async_add_entities( LinearCoverEntity(coordinator, device_id, device_data.name, sub_device_id) diff --git a/homeassistant/components/linear_garage_door/diagnostics.py b/homeassistant/components/linear_garage_door/diagnostics.py index 21414f02f871b3..ff5ca5639bfa2e 100644 --- a/homeassistant/components/linear_garage_door/diagnostics.py +++ b/homeassistant/components/linear_garage_door/diagnostics.py @@ -6,21 +6,19 @@ from typing import Any from homeassistant.components.diagnostics import async_redact_data -from homeassistant.config_entries import ConfigEntry from homeassistant.const import CONF_EMAIL, CONF_PASSWORD from homeassistant.core import HomeAssistant -from .const import DOMAIN -from .coordinator import LinearUpdateCoordinator +from .coordinator import LinearConfigEntry TO_REDACT = {CONF_PASSWORD, CONF_EMAIL} async def async_get_config_entry_diagnostics( - hass: HomeAssistant, entry: ConfigEntry + hass: HomeAssistant, entry: LinearConfigEntry ) -> dict[str, Any]: """Return diagnostics for a config entry.""" - coordinator: LinearUpdateCoordinator = hass.data[DOMAIN][entry.entry_id] + coordinator = entry.runtime_data return { "entry": async_redact_data(entry.as_dict(), TO_REDACT), diff --git a/homeassistant/components/linear_garage_door/light.py b/homeassistant/components/linear_garage_door/light.py index ac03894d44682a..59243817fbb07c 100644 --- a/homeassistant/components/linear_garage_door/light.py +++ b/homeassistant/components/linear_garage_door/light.py @@ -5,12 +5,10 @@ from linear_garage_door import Linear from homeassistant.components.light import ATTR_BRIGHTNESS, ColorMode, LightEntity -from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import DOMAIN -from .coordinator import LinearUpdateCoordinator +from .coordinator import LinearConfigEntry from .entity import LinearEntity SUPPORTED_SUBDEVICES = ["Light"] @@ -18,11 +16,11 @@ async def async_setup_entry( hass: HomeAssistant, - config_entry: ConfigEntry, + config_entry: LinearConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up Linear Garage Door cover.""" - coordinator: LinearUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id] + coordinator = config_entry.runtime_data data = coordinator.data async_add_entities( From ce115cbfe15ef14617a0eeb6c623025e4ab2636c Mon Sep 17 00:00:00 2001 From: Josef Zweck Date: Mon, 23 Jun 2025 19:08:48 +0200 Subject: [PATCH 07/30] Bump aiotedee to 0.2.25 (#147349) * Bump aiotedee to 0.2.24 * bump to 25 * fix snapshot --- homeassistant/components/tedee/manifest.json | 2 +- requirements_all.txt | 2 +- requirements_test_all.txt | 2 +- tests/components/tedee/snapshots/test_diagnostics.ambr | 2 ++ 4 files changed, 5 insertions(+), 3 deletions(-) diff --git a/homeassistant/components/tedee/manifest.json b/homeassistant/components/tedee/manifest.json index 012e82318ed4f1..6e0f6ee588b49d 100644 --- a/homeassistant/components/tedee/manifest.json +++ b/homeassistant/components/tedee/manifest.json @@ -8,5 +8,5 @@ "iot_class": "local_push", "loggers": ["aiotedee"], "quality_scale": "platinum", - "requirements": ["aiotedee==0.2.23"] + "requirements": ["aiotedee==0.2.25"] } diff --git a/requirements_all.txt b/requirements_all.txt index 8e35b3f0f7c5e5..da730bd041c877 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -405,7 +405,7 @@ aiosyncthing==0.5.1 aiotankerkoenig==0.4.2 # homeassistant.components.tedee -aiotedee==0.2.23 +aiotedee==0.2.25 # homeassistant.components.tractive aiotractive==0.6.0 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index 409e1bc19e20a2..f03fcba0cdc9f3 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -387,7 +387,7 @@ aiosyncthing==0.5.1 aiotankerkoenig==0.4.2 # homeassistant.components.tedee -aiotedee==0.2.23 +aiotedee==0.2.25 # homeassistant.components.tractive aiotractive==0.6.0 diff --git a/tests/components/tedee/snapshots/test_diagnostics.ambr b/tests/components/tedee/snapshots/test_diagnostics.ambr index 046a8fd210ac16..63707477df9c65 100644 --- a/tests/components/tedee/snapshots/test_diagnostics.ambr +++ b/tests/components/tedee/snapshots/test_diagnostics.ambr @@ -3,6 +3,7 @@ dict({ '0': dict({ 'battery_level': 70, + 'door_state': 0, 'duration_pullspring': 2, 'is_charging': False, 'is_connected': True, @@ -16,6 +17,7 @@ }), '1': dict({ 'battery_level': 70, + 'door_state': 0, 'duration_pullspring': 0, 'is_charging': False, 'is_connected': True, From dfa3fddd355de065b92de56cc41d91ca2066336e Mon Sep 17 00:00:00 2001 From: epenet <6771947+epenet@users.noreply.github.com> Date: Mon, 23 Jun 2025 19:09:38 +0200 Subject: [PATCH 08/30] Migrate livisi to use runtime_data (#147352) --- homeassistant/components/livisi/__init__.py | 19 ++++++------------- .../components/livisi/binary_sensor.py | 13 ++++++------- homeassistant/components/livisi/climate.py | 10 ++++------ .../components/livisi/coordinator.py | 6 ++++-- homeassistant/components/livisi/entity.py | 5 ++--- homeassistant/components/livisi/switch.py | 11 +++++------ 6 files changed, 27 insertions(+), 37 deletions(-) diff --git a/homeassistant/components/livisi/__init__.py b/homeassistant/components/livisi/__init__.py index fc9e381a1c3a0f..befbe6858ef65c 100644 --- a/homeassistant/components/livisi/__init__.py +++ b/homeassistant/components/livisi/__init__.py @@ -8,19 +8,18 @@ from livisi.aiolivisi import AioLivisi from homeassistant import core -from homeassistant.config_entries import ConfigEntry from homeassistant.const import Platform from homeassistant.core import HomeAssistant from homeassistant.exceptions import ConfigEntryNotReady from homeassistant.helpers import aiohttp_client, device_registry as dr from .const import DOMAIN -from .coordinator import LivisiDataUpdateCoordinator +from .coordinator import LivisiConfigEntry, LivisiDataUpdateCoordinator PLATFORMS: Final = [Platform.BINARY_SENSOR, Platform.CLIMATE, Platform.SWITCH] -async def async_setup_entry(hass: core.HomeAssistant, entry: ConfigEntry) -> bool: +async def async_setup_entry(hass: core.HomeAssistant, entry: LivisiConfigEntry) -> bool: """Set up Livisi Smart Home from a config entry.""" web_session = aiohttp_client.async_get_clientsession(hass) aiolivisi = AioLivisi(web_session) @@ -31,7 +30,7 @@ async def async_setup_entry(hass: core.HomeAssistant, entry: ConfigEntry) -> boo except ClientConnectorError as exception: raise ConfigEntryNotReady from exception - hass.data.setdefault(DOMAIN, {})[entry.entry_id] = coordinator + entry.runtime_data = coordinator device_registry = dr.async_get(hass) device_registry.async_get_or_create( config_entry_id=entry.entry_id, @@ -45,16 +44,10 @@ async def async_setup_entry(hass: core.HomeAssistant, entry: ConfigEntry) -> boo entry.async_create_background_task( hass, coordinator.ws_connect(), "livisi-ws_connect" ) + entry.async_on_unload(coordinator.websocket.disconnect) return True -async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: +async def async_unload_entry(hass: HomeAssistant, entry: LivisiConfigEntry) -> bool: """Unload a config entry.""" - coordinator = hass.data[DOMAIN][entry.entry_id] - - unload_success = await hass.config_entries.async_unload_platforms(entry, PLATFORMS) - await coordinator.websocket.disconnect() - if unload_success: - hass.data[DOMAIN].pop(entry.entry_id) - - return unload_success + return await hass.config_entries.async_unload_platforms(entry, PLATFORMS) diff --git a/homeassistant/components/livisi/binary_sensor.py b/homeassistant/components/livisi/binary_sensor.py index 50eb4cd28b958f..ea61e7741b88e8 100644 --- a/homeassistant/components/livisi/binary_sensor.py +++ b/homeassistant/components/livisi/binary_sensor.py @@ -8,23 +8,22 @@ BinarySensorDeviceClass, BinarySensorEntity, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant, callback from homeassistant.helpers.dispatcher import async_dispatcher_connect from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import DOMAIN, LIVISI_STATE_CHANGE, LOGGER, WDS_DEVICE_TYPE -from .coordinator import LivisiDataUpdateCoordinator +from .const import LIVISI_STATE_CHANGE, LOGGER, WDS_DEVICE_TYPE +from .coordinator import LivisiConfigEntry, LivisiDataUpdateCoordinator from .entity import LivisiEntity async def async_setup_entry( hass: HomeAssistant, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up binary_sensor device.""" - coordinator: LivisiDataUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id] + coordinator = config_entry.runtime_data known_devices = set() @callback @@ -53,7 +52,7 @@ class LivisiBinarySensor(LivisiEntity, BinarySensorEntity): def __init__( self, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, coordinator: LivisiDataUpdateCoordinator, device: dict[str, Any], capability_name: str, @@ -86,7 +85,7 @@ class LivisiWindowDoorSensor(LivisiBinarySensor): def __init__( self, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, coordinator: LivisiDataUpdateCoordinator, device: dict[str, Any], ) -> None: diff --git a/homeassistant/components/livisi/climate.py b/homeassistant/components/livisi/climate.py index 1f5e3360c7db30..05539043d74d16 100644 --- a/homeassistant/components/livisi/climate.py +++ b/homeassistant/components/livisi/climate.py @@ -11,7 +11,6 @@ ClimateEntityFeature, HVACMode, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import HomeAssistantError @@ -19,24 +18,23 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback from .const import ( - DOMAIN, LIVISI_STATE_CHANGE, LOGGER, MAX_TEMPERATURE, MIN_TEMPERATURE, VRCC_DEVICE_TYPE, ) -from .coordinator import LivisiDataUpdateCoordinator +from .coordinator import LivisiConfigEntry, LivisiDataUpdateCoordinator from .entity import LivisiEntity async def async_setup_entry( hass: HomeAssistant, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up climate device.""" - coordinator: LivisiDataUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id] + coordinator = config_entry.runtime_data @callback def handle_coordinator_update() -> None: @@ -71,7 +69,7 @@ class LivisiClimate(LivisiEntity, ClimateEntity): def __init__( self, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, coordinator: LivisiDataUpdateCoordinator, device: dict[str, Any], ) -> None: diff --git a/homeassistant/components/livisi/coordinator.py b/homeassistant/components/livisi/coordinator.py index 6557416ed3a672..8d490dca952a3c 100644 --- a/homeassistant/components/livisi/coordinator.py +++ b/homeassistant/components/livisi/coordinator.py @@ -26,14 +26,16 @@ LOGGER, ) +type LivisiConfigEntry = ConfigEntry[LivisiDataUpdateCoordinator] + class LivisiDataUpdateCoordinator(DataUpdateCoordinator[list[dict[str, Any]]]): """Class to manage fetching LIVISI data API.""" - config_entry: ConfigEntry + config_entry: LivisiConfigEntry def __init__( - self, hass: HomeAssistant, config_entry: ConfigEntry, aiolivisi: AioLivisi + self, hass: HomeAssistant, config_entry: LivisiConfigEntry, aiolivisi: AioLivisi ) -> None: """Initialize my coordinator.""" super().__init__( diff --git a/homeassistant/components/livisi/entity.py b/homeassistant/components/livisi/entity.py index af588b0e3606a8..79af35c1f8c3e3 100644 --- a/homeassistant/components/livisi/entity.py +++ b/homeassistant/components/livisi/entity.py @@ -7,14 +7,13 @@ from livisi.const import CAPABILITY_MAP -from homeassistant.config_entries import ConfigEntry from homeassistant.core import callback from homeassistant.helpers.device_registry import DeviceInfo from homeassistant.helpers.dispatcher import async_dispatcher_connect from homeassistant.helpers.update_coordinator import CoordinatorEntity from .const import DOMAIN, LIVISI_REACHABILITY_CHANGE -from .coordinator import LivisiDataUpdateCoordinator +from .coordinator import LivisiConfigEntry, LivisiDataUpdateCoordinator class LivisiEntity(CoordinatorEntity[LivisiDataUpdateCoordinator]): @@ -24,7 +23,7 @@ class LivisiEntity(CoordinatorEntity[LivisiDataUpdateCoordinator]): def __init__( self, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, coordinator: LivisiDataUpdateCoordinator, device: dict[str, Any], *, diff --git a/homeassistant/components/livisi/switch.py b/homeassistant/components/livisi/switch.py index 5599a4af0d4fa5..e053923f551e20 100644 --- a/homeassistant/components/livisi/switch.py +++ b/homeassistant/components/livisi/switch.py @@ -5,24 +5,23 @@ from typing import Any from homeassistant.components.switch import SwitchEntity -from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant, callback from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers.dispatcher import async_dispatcher_connect from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import DOMAIN, LIVISI_STATE_CHANGE, LOGGER, SWITCH_DEVICE_TYPES -from .coordinator import LivisiDataUpdateCoordinator +from .const import LIVISI_STATE_CHANGE, LOGGER, SWITCH_DEVICE_TYPES +from .coordinator import LivisiConfigEntry, LivisiDataUpdateCoordinator from .entity import LivisiEntity async def async_setup_entry( hass: HomeAssistant, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up switch device.""" - coordinator: LivisiDataUpdateCoordinator = hass.data[DOMAIN][config_entry.entry_id] + coordinator = config_entry.runtime_data @callback def handle_coordinator_update() -> None: @@ -52,7 +51,7 @@ class LivisiSwitch(LivisiEntity, SwitchEntity): def __init__( self, - config_entry: ConfigEntry, + config_entry: LivisiConfigEntry, coordinator: LivisiDataUpdateCoordinator, device: dict[str, Any], ) -> None: From a7de947f00e87cb68b97d2bc79e08beb23abab3e Mon Sep 17 00:00:00 2001 From: G Johansson Date: Mon, 23 Jun 2025 19:12:18 +0200 Subject: [PATCH 09/30] Add vacuum activity to pylint type hints check (#147162) --- pylint/plugins/hass_enforce_type_hints.py | 4 ++++ tests/pylint/test_enforce_type_hints.py | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/pylint/plugins/hass_enforce_type_hints.py b/pylint/plugins/hass_enforce_type_hints.py index 0760cd338211fd..32a053527f6d06 100644 --- a/pylint/plugins/hass_enforce_type_hints.py +++ b/pylint/plugins/hass_enforce_type_hints.py @@ -2795,6 +2795,10 @@ class ClassTypeHintMatch: function_name="state", return_type=["str", None], ), + TypeHintMatch( + function_name="activity", + return_type=["VacuumActivity", None], + ), TypeHintMatch( function_name="battery_level", return_type=["int", None], diff --git a/tests/pylint/test_enforce_type_hints.py b/tests/pylint/test_enforce_type_hints.py index ae426b13fcb09e..41605bf2f2ba72 100644 --- a/tests/pylint/test_enforce_type_hints.py +++ b/tests/pylint/test_enforce_type_hints.py @@ -1167,6 +1167,10 @@ class StateVacuumEntity(Entity): class MyVacuum( #@ StateVacuumEntity ): + @property + def activity(self) -> VacuumActivity | None: + pass + def send_command( self, command: str, From 6b242fd27792f7ffdfd5511e9c1359f24e882ccc Mon Sep 17 00:00:00 2001 From: epenet <6771947+epenet@users.noreply.github.com> Date: Mon, 23 Jun 2025 20:01:21 +0200 Subject: [PATCH 10/30] Migrate lifx to use runtime_data and HassKey (#147348) --- homeassistant/components/lifx/__init__.py | 25 ++++++++----------- .../components/lifx/binary_sensor.py | 9 +++---- homeassistant/components/lifx/button.py | 10 +++----- homeassistant/components/lifx/const.py | 10 +++++++- homeassistant/components/lifx/coordinator.py | 6 +++-- homeassistant/components/lifx/diagnostics.py | 9 +++---- homeassistant/components/lifx/light.py | 12 ++++----- homeassistant/components/lifx/manager.py | 16 ++++++------ homeassistant/components/lifx/migration.py | 6 ++--- homeassistant/components/lifx/select.py | 14 +++-------- homeassistant/components/lifx/sensor.py | 9 +++---- homeassistant/components/lifx/util.py | 10 +++++--- 12 files changed, 64 insertions(+), 72 deletions(-) diff --git a/homeassistant/components/lifx/__init__.py b/homeassistant/components/lifx/__init__.py index 7a6d95549ff125..99a8adb0182c40 100644 --- a/homeassistant/components/lifx/__init__.py +++ b/homeassistant/components/lifx/__init__.py @@ -13,7 +13,6 @@ import voluptuous as vol from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN -from homeassistant.config_entries import ConfigEntry from homeassistant.const import ( CONF_HOST, CONF_PORT, @@ -27,7 +26,7 @@ from homeassistant.helpers.typing import ConfigType from .const import _LOGGER, DATA_LIFX_MANAGER, DOMAIN, TARGET_ANY -from .coordinator import LIFXUpdateCoordinator +from .coordinator import LIFXConfigEntry, LIFXUpdateCoordinator from .discovery import async_discover_devices, async_trigger_discovery from .manager import LIFXManager from .migration import async_migrate_entities_devices, async_migrate_legacy_entries @@ -73,7 +72,7 @@ async def async_legacy_migration( hass: HomeAssistant, - legacy_entry: ConfigEntry, + legacy_entry: LIFXConfigEntry, discovered_devices: Iterable[Light], ) -> bool: """Migrate config entries.""" @@ -157,7 +156,6 @@ async def async_discovery(self, *_: Any) -> None: async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Set up the LIFX component.""" - hass.data[DOMAIN] = {} migrating = bool(async_get_legacy_entry(hass)) discovery_manager = LIFXDiscoveryManager(hass, migrating) @@ -187,7 +185,7 @@ def _async_delayed_discovery(now: datetime) -> None: return True -async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: +async def async_setup_entry(hass: HomeAssistant, entry: LIFXConfigEntry) -> bool: """Set up LIFX from a config entry.""" if async_entry_is_legacy(entry): return True @@ -198,10 +196,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: async_migrate_entities_devices(hass, legacy_entry.entry_id, entry) assert entry.unique_id is not None - domain_data = hass.data[DOMAIN] - if DATA_LIFX_MANAGER not in domain_data: + if DATA_LIFX_MANAGER not in hass.data: manager = LIFXManager(hass) - domain_data[DATA_LIFX_MANAGER] = manager + hass.data[DATA_LIFX_MANAGER] = manager manager.async_setup() host = entry.data[CONF_HOST] @@ -229,21 +226,19 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: raise ConfigEntryNotReady( f"Unexpected device found at {host}; expected {entry.unique_id}, found {serial}" ) - domain_data[entry.entry_id] = coordinator + entry.runtime_data = coordinator await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) return True -async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: +async def async_unload_entry(hass: HomeAssistant, entry: LIFXConfigEntry) -> bool: """Unload a config entry.""" if async_entry_is_legacy(entry): return True - domain_data = hass.data[DOMAIN] if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS): - coordinator: LIFXUpdateCoordinator = domain_data.pop(entry.entry_id) - coordinator.connection.async_stop() + entry.runtime_data.connection.async_stop() # Only the DATA_LIFX_MANAGER left, remove it. - if len(domain_data) == 1: - manager: LIFXManager = domain_data.pop(DATA_LIFX_MANAGER) + if len(hass.config_entries.async_loaded_entries(DOMAIN)) == 0: + manager = hass.data.pop(DATA_LIFX_MANAGER) manager.async_unload() return unload_ok diff --git a/homeassistant/components/lifx/binary_sensor.py b/homeassistant/components/lifx/binary_sensor.py index f5a974b46267a8..478a4d306e219d 100644 --- a/homeassistant/components/lifx/binary_sensor.py +++ b/homeassistant/components/lifx/binary_sensor.py @@ -7,13 +7,12 @@ BinarySensorEntity, BinarySensorEntityDescription, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.const import EntityCategory from homeassistant.core import HomeAssistant, callback from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import DOMAIN, HEV_CYCLE_STATE -from .coordinator import LIFXUpdateCoordinator +from .const import HEV_CYCLE_STATE +from .coordinator import LIFXConfigEntry, LIFXUpdateCoordinator from .entity import LIFXEntity from .util import lifx_features @@ -27,11 +26,11 @@ async def async_setup_entry( hass: HomeAssistant, - entry: ConfigEntry, + entry: LIFXConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up LIFX from a config entry.""" - coordinator: LIFXUpdateCoordinator = hass.data[DOMAIN][entry.entry_id] + coordinator = entry.runtime_data if lifx_features(coordinator.device)["hev"]: async_add_entities( diff --git a/homeassistant/components/lifx/button.py b/homeassistant/components/lifx/button.py index 25ab61aebae00d..758d7ab64356e7 100644 --- a/homeassistant/components/lifx/button.py +++ b/homeassistant/components/lifx/button.py @@ -7,13 +7,12 @@ ButtonEntity, ButtonEntityDescription, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.const import EntityCategory from homeassistant.core import HomeAssistant from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import DOMAIN, IDENTIFY, RESTART -from .coordinator import LIFXUpdateCoordinator +from .const import IDENTIFY, RESTART +from .coordinator import LIFXConfigEntry, LIFXUpdateCoordinator from .entity import LIFXEntity RESTART_BUTTON_DESCRIPTION = ButtonEntityDescription( @@ -31,12 +30,11 @@ async def async_setup_entry( hass: HomeAssistant, - entry: ConfigEntry, + entry: LIFXConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up LIFX from a config entry.""" - domain_data = hass.data[DOMAIN] - coordinator: LIFXUpdateCoordinator = domain_data[entry.entry_id] + coordinator = entry.runtime_data async_add_entities( [LIFXRestartButton(coordinator), LIFXIdentifyButton(coordinator)] ) diff --git a/homeassistant/components/lifx/const.py b/homeassistant/components/lifx/const.py index 58c3550b812de1..ecc572aa006037 100644 --- a/homeassistant/components/lifx/const.py +++ b/homeassistant/components/lifx/const.py @@ -1,8 +1,17 @@ """Const for LIFX.""" +from __future__ import annotations + import logging +from typing import TYPE_CHECKING + +from homeassistant.util.hass_dict import HassKey + +if TYPE_CHECKING: + from .manager import LIFXManager DOMAIN = "lifx" +DATA_LIFX_MANAGER: HassKey[LIFXManager] = HassKey(DOMAIN) TARGET_ANY = "00:00:00:00:00:00" @@ -59,7 +68,6 @@ 32767: "50%", 65535: "100%", } -DATA_LIFX_MANAGER = "lifx_manager" LIFX_CEILING_PRODUCT_IDS = {176, 177, 201, 202} diff --git a/homeassistant/components/lifx/coordinator.py b/homeassistant/components/lifx/coordinator.py index b77dbdc015a72f..79ce843b339eda 100644 --- a/homeassistant/components/lifx/coordinator.py +++ b/homeassistant/components/lifx/coordinator.py @@ -65,6 +65,8 @@ RSSI_DBM_FW = AwesomeVersion("2.77") +type LIFXConfigEntry = ConfigEntry[LIFXUpdateCoordinator] + class FirmwareEffect(IntEnum): """Enumeration of LIFX firmware effects.""" @@ -87,12 +89,12 @@ class SkyType(IntEnum): class LIFXUpdateCoordinator(DataUpdateCoordinator[None]): """DataUpdateCoordinator to gather data for a specific lifx device.""" - config_entry: ConfigEntry + config_entry: LIFXConfigEntry def __init__( self, hass: HomeAssistant, - config_entry: ConfigEntry, + config_entry: LIFXConfigEntry, connection: LIFXConnection, ) -> None: """Initialize DataUpdateCoordinator.""" diff --git a/homeassistant/components/lifx/diagnostics.py b/homeassistant/components/lifx/diagnostics.py index b9ef1af4dc6200..64e7390b210485 100644 --- a/homeassistant/components/lifx/diagnostics.py +++ b/homeassistant/components/lifx/diagnostics.py @@ -5,21 +5,20 @@ from typing import Any from homeassistant.components.diagnostics import async_redact_data -from homeassistant.config_entries import ConfigEntry from homeassistant.const import CONF_HOST, CONF_IP_ADDRESS, CONF_MAC from homeassistant.core import HomeAssistant -from .const import CONF_LABEL, DOMAIN -from .coordinator import LIFXUpdateCoordinator +from .const import CONF_LABEL +from .coordinator import LIFXConfigEntry TO_REDACT = [CONF_LABEL, CONF_HOST, CONF_IP_ADDRESS, CONF_MAC] async def async_get_config_entry_diagnostics( - hass: HomeAssistant, entry: ConfigEntry + hass: HomeAssistant, entry: LIFXConfigEntry ) -> dict[str, Any]: """Return diagnostics for a LIFX config entry.""" - coordinator: LIFXUpdateCoordinator = hass.data[DOMAIN][entry.entry_id] + coordinator = entry.runtime_data return { "entry": { "title": entry.title, diff --git a/homeassistant/components/lifx/light.py b/homeassistant/components/lifx/light.py index 5641786eb61ba7..3d30fcd369e4f2 100644 --- a/homeassistant/components/lifx/light.py +++ b/homeassistant/components/lifx/light.py @@ -17,7 +17,6 @@ LightEntity, LightEntityFeature, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.const import ATTR_ENTITY_ID, Platform from homeassistant.core import CALLBACK_TYPE, HomeAssistant from homeassistant.exceptions import HomeAssistantError @@ -37,7 +36,7 @@ INFRARED_BRIGHTNESS, LIFX_CEILING_PRODUCT_IDS, ) -from .coordinator import FirmwareEffect, LIFXUpdateCoordinator +from .coordinator import FirmwareEffect, LIFXConfigEntry, LIFXUpdateCoordinator from .entity import LIFXEntity from .manager import ( SERVICE_EFFECT_COLORLOOP, @@ -78,13 +77,12 @@ async def async_setup_entry( hass: HomeAssistant, - entry: ConfigEntry, + entry: LIFXConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up LIFX from a config entry.""" - domain_data = hass.data[DOMAIN] - coordinator: LIFXUpdateCoordinator = domain_data[entry.entry_id] - manager: LIFXManager = domain_data[DATA_LIFX_MANAGER] + coordinator = entry.runtime_data + manager = hass.data[DATA_LIFX_MANAGER] device = coordinator.device platform = entity_platform.async_get_current_platform() platform.async_register_entity_service( @@ -123,7 +121,7 @@ def __init__( self, coordinator: LIFXUpdateCoordinator, manager: LIFXManager, - entry: ConfigEntry, + entry: LIFXConfigEntry, ) -> None: """Initialize the light.""" super().__init__(coordinator) diff --git a/homeassistant/components/lifx/manager.py b/homeassistant/components/lifx/manager.py index 9fae2628f1dc73..33712441157fad 100644 --- a/homeassistant/components/lifx/manager.py +++ b/homeassistant/components/lifx/manager.py @@ -30,8 +30,8 @@ from homeassistant.helpers import config_validation as cv from homeassistant.helpers.service import async_extract_referenced_entity_ids -from .const import _ATTR_COLOR_TEMP, ATTR_THEME, DATA_LIFX_MANAGER, DOMAIN -from .coordinator import LIFXUpdateCoordinator +from .const import _ATTR_COLOR_TEMP, ATTR_THEME, DOMAIN +from .coordinator import LIFXConfigEntry, LIFXUpdateCoordinator from .util import convert_8_to_16, find_hsbk if TYPE_CHECKING: @@ -494,13 +494,11 @@ async def start_effect( coordinators: list[LIFXUpdateCoordinator] = [] bulbs: list[Light] = [] - for entry_id, coordinator in self.hass.data[DOMAIN].items(): - if ( - entry_id != DATA_LIFX_MANAGER - and self.entry_id_to_entity_id[entry_id] in entity_ids - ): - coordinators.append(coordinator) - bulbs.append(coordinator.device) + entry: LIFXConfigEntry + for entry in self.hass.config_entries.async_loaded_entries(DOMAIN): + if self.entry_id_to_entity_id[entry.entry_id] in entity_ids: + coordinators.append(entry.runtime_data) + bulbs.append(entry.runtime_data.device) if start_effect_func := self._effect_dispatch.get(service): await start_effect_func(self, bulbs, coordinators, **kwargs) diff --git a/homeassistant/components/lifx/migration.py b/homeassistant/components/lifx/migration.py index 9f8365cbceb4e9..1e8855e40db9ff 100644 --- a/homeassistant/components/lifx/migration.py +++ b/homeassistant/components/lifx/migration.py @@ -2,11 +2,11 @@ from __future__ import annotations -from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant, callback from homeassistant.helpers import device_registry as dr, entity_registry as er from .const import _LOGGER, DOMAIN +from .coordinator import LIFXConfigEntry from .discovery import async_init_discovery_flow @@ -15,7 +15,7 @@ def async_migrate_legacy_entries( hass: HomeAssistant, discovered_hosts_by_serial: dict[str, str], existing_serials: set[str], - legacy_entry: ConfigEntry, + legacy_entry: LIFXConfigEntry, ) -> int: """Migrate the legacy config entries to have an entry per device.""" _LOGGER.debug( @@ -45,7 +45,7 @@ def async_migrate_legacy_entries( @callback def async_migrate_entities_devices( - hass: HomeAssistant, legacy_entry_id: str, new_entry: ConfigEntry + hass: HomeAssistant, legacy_entry_id: str, new_entry: LIFXConfigEntry ) -> None: """Move entities and devices to the new config entry.""" migrated_devices = [] diff --git a/homeassistant/components/lifx/select.py b/homeassistant/components/lifx/select.py index 13b81e2a784a29..0913d7a1662d67 100644 --- a/homeassistant/components/lifx/select.py +++ b/homeassistant/components/lifx/select.py @@ -5,18 +5,12 @@ from aiolifx_themes.themes import ThemeLibrary from homeassistant.components.select import SelectEntity, SelectEntityDescription -from homeassistant.config_entries import ConfigEntry from homeassistant.const import EntityCategory from homeassistant.core import HomeAssistant, callback from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import ( - ATTR_THEME, - DOMAIN, - INFRARED_BRIGHTNESS, - INFRARED_BRIGHTNESS_VALUES_MAP, -) -from .coordinator import LIFXUpdateCoordinator +from .const import ATTR_THEME, INFRARED_BRIGHTNESS, INFRARED_BRIGHTNESS_VALUES_MAP +from .coordinator import LIFXConfigEntry, LIFXUpdateCoordinator from .entity import LIFXEntity from .util import lifx_features @@ -39,11 +33,11 @@ async def async_setup_entry( hass: HomeAssistant, - entry: ConfigEntry, + entry: LIFXConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up LIFX from a config entry.""" - coordinator: LIFXUpdateCoordinator = hass.data[DOMAIN][entry.entry_id] + coordinator = entry.runtime_data entities: list[LIFXEntity] = [] diff --git a/homeassistant/components/lifx/sensor.py b/homeassistant/components/lifx/sensor.py index 96feba633f4c51..8a9877dc4681e3 100644 --- a/homeassistant/components/lifx/sensor.py +++ b/homeassistant/components/lifx/sensor.py @@ -10,13 +10,12 @@ SensorEntityDescription, SensorStateClass, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.const import EntityCategory from homeassistant.core import HomeAssistant, callback from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from .const import ATTR_RSSI, DOMAIN -from .coordinator import LIFXUpdateCoordinator +from .const import ATTR_RSSI +from .coordinator import LIFXConfigEntry, LIFXUpdateCoordinator from .entity import LIFXEntity SCAN_INTERVAL = timedelta(seconds=30) @@ -33,11 +32,11 @@ async def async_setup_entry( hass: HomeAssistant, - entry: ConfigEntry, + entry: LIFXConfigEntry, async_add_entities: AddConfigEntryEntitiesCallback, ) -> None: """Set up LIFX sensor from config entry.""" - coordinator: LIFXUpdateCoordinator = hass.data[DOMAIN][entry.entry_id] + coordinator = entry.runtime_data async_add_entities([LIFXRssiSensor(coordinator, RSSI_SENSOR)]) diff --git a/homeassistant/components/lifx/util.py b/homeassistant/components/lifx/util.py index 8286622e6f3678..c99880891d2664 100644 --- a/homeassistant/components/lifx/util.py +++ b/homeassistant/components/lifx/util.py @@ -5,7 +5,7 @@ import asyncio from collections.abc import Callable from functools import partial -from typing import Any +from typing import TYPE_CHECKING, Any from aiolifx import products from aiolifx.aiolifx import Light @@ -21,7 +21,6 @@ ATTR_RGB_COLOR, ATTR_XY_COLOR, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.core import HomeAssistant, callback from homeassistant.helpers import device_registry as dr from homeassistant.util import color as color_util @@ -35,17 +34,20 @@ OVERALL_TIMEOUT, ) +if TYPE_CHECKING: + from .coordinator import LIFXConfigEntry + FIX_MAC_FW = AwesomeVersion("3.70") @callback -def async_entry_is_legacy(entry: ConfigEntry) -> bool: +def async_entry_is_legacy(entry: LIFXConfigEntry) -> bool: """Check if a config entry is the legacy shared one.""" return entry.unique_id is None or entry.unique_id == DOMAIN @callback -def async_get_legacy_entry(hass: HomeAssistant) -> ConfigEntry | None: +def async_get_legacy_entry(hass: HomeAssistant) -> LIFXConfigEntry | None: """Get the legacy config entry.""" for entry in hass.config_entries.async_entries(DOMAIN): if async_entry_is_legacy(entry): From 442fb88011d1f9dfe5bc4067d9ed46836c52cb19 Mon Sep 17 00:00:00 2001 From: Joost Lekkerkerker Date: Mon, 23 Jun 2025 20:08:13 +0200 Subject: [PATCH 11/30] Add update platform to LaMetric (#147354) --- homeassistant/components/lametric/const.py | 1 + homeassistant/components/lametric/update.py | 46 ++++++++++++++ tests/components/lametric/conftest.py | 15 ++++- .../lametric/fixtures/device_sa5.json | 3 + .../lametric/snapshots/test_update.ambr | 62 +++++++++++++++++++ tests/components/lametric/test_update.py | 29 +++++++++ 6 files changed, 153 insertions(+), 3 deletions(-) create mode 100644 homeassistant/components/lametric/update.py create mode 100644 tests/components/lametric/snapshots/test_update.ambr create mode 100644 tests/components/lametric/test_update.py diff --git a/homeassistant/components/lametric/const.py b/homeassistant/components/lametric/const.py index 4f9472b24f4636..8c05b15ad1f54a 100644 --- a/homeassistant/components/lametric/const.py +++ b/homeassistant/components/lametric/const.py @@ -13,6 +13,7 @@ Platform.SELECT, Platform.SENSOR, Platform.SWITCH, + Platform.UPDATE, ] LOGGER = logging.getLogger(__package__) diff --git a/homeassistant/components/lametric/update.py b/homeassistant/components/lametric/update.py new file mode 100644 index 00000000000000..d486d9d27ba38f --- /dev/null +++ b/homeassistant/components/lametric/update.py @@ -0,0 +1,46 @@ +"""LaMetric Update platform.""" + +from awesomeversion import AwesomeVersion + +from homeassistant.components.update import UpdateDeviceClass, UpdateEntity +from homeassistant.core import HomeAssistant +from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback + +from .coordinator import LaMetricConfigEntry, LaMetricDataUpdateCoordinator +from .entity import LaMetricEntity + + +async def async_setup_entry( + hass: HomeAssistant, + config_entry: LaMetricConfigEntry, + async_add_entities: AddConfigEntryEntitiesCallback, +) -> None: + """Set up LaMetric update platform.""" + + coordinator = config_entry.runtime_data + + if coordinator.data.os_version >= AwesomeVersion("2.3.0"): + async_add_entities([LaMetricUpdate(coordinator)]) + + +class LaMetricUpdate(LaMetricEntity, UpdateEntity): + """Representation of LaMetric Update.""" + + _attr_device_class = UpdateDeviceClass.FIRMWARE + + def __init__(self, coordinator: LaMetricDataUpdateCoordinator) -> None: + """Initialize the entity.""" + super().__init__(coordinator) + self._attr_unique_id = f"{coordinator.data.serial_number}-update" + + @property + def installed_version(self) -> str: + """Return the installed version of the entity.""" + return self.coordinator.data.os_version + + @property + def latest_version(self) -> str | None: + """Return the latest version of the entity.""" + if not self.coordinator.data.update: + return None + return self.coordinator.data.update.version diff --git a/tests/components/lametric/conftest.py b/tests/components/lametric/conftest.py index da86d1bc4de26c..f88370546917d8 100644 --- a/tests/components/lametric/conftest.py +++ b/tests/components/lametric/conftest.py @@ -3,6 +3,7 @@ from __future__ import annotations from collections.abc import Generator +from contextlib import nullcontext from unittest.mock import AsyncMock, MagicMock, patch from demetriek import CloudDevice, Device @@ -97,12 +98,20 @@ def mock_lametric(device_fixture: str) -> Generator[MagicMock]: @pytest.fixture async def init_integration( - hass: HomeAssistant, mock_config_entry: MockConfigEntry, mock_lametric: MagicMock + hass: HomeAssistant, + mock_config_entry: MockConfigEntry, + mock_lametric: MagicMock, + request: pytest.FixtureRequest, ) -> MockConfigEntry: """Set up the LaMetric integration for testing.""" mock_config_entry.add_to_hass(hass) - await hass.config_entries.async_setup(mock_config_entry.entry_id) - await hass.async_block_till_done() + context = nullcontext() + if platform := getattr(request, "param", None): + context = patch("homeassistant.components.lametric.PLATFORMS", [platform]) + + with context: + await hass.config_entries.async_setup(mock_config_entry.entry_id) + await hass.async_block_till_done() return mock_config_entry diff --git a/tests/components/lametric/fixtures/device_sa5.json b/tests/components/lametric/fixtures/device_sa5.json index 47120f672efdab..b82a4bda2af2cd 100644 --- a/tests/components/lametric/fixtures/device_sa5.json +++ b/tests/components/lametric/fixtures/device_sa5.json @@ -57,6 +57,9 @@ "name": "spyfly's LaMetric SKY", "os_version": "3.0.13", "serial_number": "SA52100000123TBNC", + "update_available": { + "version": "3.2.1" + }, "wifi": { "active": true, "mac": "AA:BB:CC:DD:EE:FF", diff --git a/tests/components/lametric/snapshots/test_update.ambr b/tests/components/lametric/snapshots/test_update.ambr new file mode 100644 index 00000000000000..342cac5b39b63f --- /dev/null +++ b/tests/components/lametric/snapshots/test_update.ambr @@ -0,0 +1,62 @@ +# serializer version: 1 +# name: test_all_entities[device_sa5-update][update.spyfly_s_lametric_sky_firmware-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'update', + 'entity_category': , + 'entity_id': 'update.spyfly_s_lametric_sky_firmware', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Firmware', + 'platform': 'lametric', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': 'SA52100000123TBNC-update', + 'unit_of_measurement': None, + }) +# --- +# name: test_all_entities[device_sa5-update][update.spyfly_s_lametric_sky_firmware-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'auto_update': False, + 'device_class': 'firmware', + 'display_precision': 0, + 'entity_picture': 'https://brands.home-assistant.io/_/lametric/icon.png', + 'friendly_name': "spyfly's LaMetric SKY Firmware", + 'in_progress': False, + 'installed_version': '3.0.13', + 'latest_version': '3.2.1', + 'release_summary': None, + 'release_url': None, + 'skipped_version': None, + 'supported_features': , + 'title': None, + 'update_percentage': None, + }), + 'context': , + 'entity_id': 'update.spyfly_s_lametric_sky_firmware', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'on', + }) +# --- diff --git a/tests/components/lametric/test_update.py b/tests/components/lametric/test_update.py new file mode 100644 index 00000000000000..f8e396bd5826db --- /dev/null +++ b/tests/components/lametric/test_update.py @@ -0,0 +1,29 @@ +"""Tests for the LaMetric update platform.""" + +from unittest.mock import MagicMock + +import pytest +from syrupy.assertion import SnapshotAssertion + +from homeassistant.const import Platform +from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er + +from tests.common import MockConfigEntry, snapshot_platform + +pytestmark = [ + pytest.mark.parametrize("init_integration", [Platform.UPDATE], indirect=True), + pytest.mark.usefixtures("init_integration"), +] + + +@pytest.mark.parametrize("device_fixture", ["device_sa5"]) +async def test_all_entities( + hass: HomeAssistant, + snapshot: SnapshotAssertion, + mock_lametric: MagicMock, + mock_config_entry: MockConfigEntry, + entity_registry: er.EntityRegistry, +) -> None: + """Test all entities.""" + await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id) From 2833e9762554ffd2a46617073cbca78356398c56 Mon Sep 17 00:00:00 2001 From: tronikos Date: Mon, 23 Jun 2025 11:11:16 -0700 Subject: [PATCH 12/30] Default to gemini-2.5-flash (#147334) --- .../google_generative_ai_conversation/const.py | 2 +- .../snapshots/test_diagnostics.ambr | 2 +- .../snapshots/test_init.ambr | 8 ++++---- .../test_config_flow.py | 14 +++++++------- 4 files changed, 13 insertions(+), 13 deletions(-) diff --git a/homeassistant/components/google_generative_ai_conversation/const.py b/homeassistant/components/google_generative_ai_conversation/const.py index 831e7d8f5085f9..7e699d7c8c0b7b 100644 --- a/homeassistant/components/google_generative_ai_conversation/const.py +++ b/homeassistant/components/google_generative_ai_conversation/const.py @@ -9,7 +9,7 @@ ATTR_MODEL = "model" CONF_RECOMMENDED = "recommended" CONF_CHAT_MODEL = "chat_model" -RECOMMENDED_CHAT_MODEL = "models/gemini-2.0-flash" +RECOMMENDED_CHAT_MODEL = "models/gemini-2.5-flash" RECOMMENDED_TTS_MODEL = "gemini-2.5-flash-preview-tts" CONF_TEMPERATURE = "temperature" RECOMMENDED_TEMPERATURE = 1.0 diff --git a/tests/components/google_generative_ai_conversation/snapshots/test_diagnostics.ambr b/tests/components/google_generative_ai_conversation/snapshots/test_diagnostics.ambr index 60d388d0502d59..a31827c7acc06f 100644 --- a/tests/components/google_generative_ai_conversation/snapshots/test_diagnostics.ambr +++ b/tests/components/google_generative_ai_conversation/snapshots/test_diagnostics.ambr @@ -5,7 +5,7 @@ 'api_key': '**REDACTED**', }), 'options': dict({ - 'chat_model': 'models/gemini-2.0-flash', + 'chat_model': 'models/gemini-2.5-flash', 'dangerous_block_threshold': 'BLOCK_MEDIUM_AND_ABOVE', 'harassment_block_threshold': 'BLOCK_MEDIUM_AND_ABOVE', 'hate_block_threshold': 'BLOCK_MEDIUM_AND_ABOVE', diff --git a/tests/components/google_generative_ai_conversation/snapshots/test_init.ambr b/tests/components/google_generative_ai_conversation/snapshots/test_init.ambr index d8e54b15f61a82..f89871ff1310d5 100644 --- a/tests/components/google_generative_ai_conversation/snapshots/test_init.ambr +++ b/tests/components/google_generative_ai_conversation/snapshots/test_init.ambr @@ -11,7 +11,7 @@ File(name='doorbell_snapshot.jpg', display_name=None, mime_type=None, size_bytes=None, create_time=None, expiration_time=None, update_time=None, sha256_hash=None, uri=None, download_uri=None, state=, source=None, video_metadata=None, error=None), File(name='context.txt', display_name=None, mime_type=None, size_bytes=None, create_time=None, expiration_time=None, update_time=None, sha256_hash=None, uri=None, download_uri=None, state=, source=None, video_metadata=None, error=None), ]), - 'model': 'models/gemini-2.0-flash', + 'model': 'models/gemini-2.5-flash', }), ), ]) @@ -28,7 +28,7 @@ b'some file', b'some file', ]), - 'model': 'models/gemini-2.0-flash', + 'model': 'models/gemini-2.5-flash', }), ), ]) @@ -43,7 +43,7 @@ 'contents': list([ 'Write an opening speech for a Home Assistant release party', ]), - 'model': 'models/gemini-2.0-flash', + 'model': 'models/gemini-2.5-flash', }), ), ]) @@ -58,7 +58,7 @@ 'contents': list([ 'Write an opening speech for a Home Assistant release party', ]), - 'model': 'models/gemini-2.0-flash', + 'model': 'models/gemini-2.5-flash', }), ), ]) diff --git a/tests/components/google_generative_ai_conversation/test_config_flow.py b/tests/components/google_generative_ai_conversation/test_config_flow.py index 4234355cb5bcb1..0dc0996ad302c0 100644 --- a/tests/components/google_generative_ai_conversation/test_config_flow.py +++ b/tests/components/google_generative_ai_conversation/test_config_flow.py @@ -41,6 +41,12 @@ def get_models_pager(): """Return a generator that yields the models.""" + model_25_flash = Mock( + display_name="Gemini 2.5 Flash", + supported_actions=["generateContent"], + ) + model_25_flash.name = "models/gemini-2.5-flash" + model_20_flash = Mock( display_name="Gemini 2.0 Flash", supported_actions=["generateContent"], @@ -59,17 +65,11 @@ def get_models_pager(): ) model_15_pro.name = "models/gemini-1.5-pro-latest" - model_10_pro = Mock( - display_name="Gemini 1.0 Pro", - supported_actions=["generateContent"], - ) - model_10_pro.name = "models/gemini-pro" - async def models_pager(): + yield model_25_flash yield model_20_flash yield model_15_flash yield model_15_pro - yield model_10_pro return models_pager() From e494f66c0275ed01b99dccebd4dfbb46237f7558 Mon Sep 17 00:00:00 2001 From: Petro31 <35082313+Petro31@users.noreply.github.com> Date: Mon, 23 Jun 2025 14:21:29 -0400 Subject: [PATCH 13/30] Add label_description to template engine (#147138) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Abílio Costa --- homeassistant/helpers/template.py | 11 ++++++++++ tests/helpers/test_template.py | 34 +++++++++++++++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/homeassistant/helpers/template.py b/homeassistant/helpers/template.py index acf78f703801ba..34b19c07f83d5d 100644 --- a/homeassistant/helpers/template.py +++ b/homeassistant/helpers/template.py @@ -1734,6 +1734,14 @@ def label_name(hass: HomeAssistant, lookup_value: str) -> str | None: return None +def label_description(hass: HomeAssistant, lookup_value: str) -> str | None: + """Get the label description from a label ID.""" + label_reg = label_registry.async_get(hass) + if label := label_reg.async_get_label(lookup_value): + return label.description + return None + + def _label_id_or_name(hass: HomeAssistant, label_id_or_name: str) -> str | None: """Get the label ID from a label name or ID.""" # If label_name returns a value, we know the input was an ID, otherwise we @@ -3314,6 +3322,9 @@ def wrapper(_: Any, *args: _P.args, **kwargs: _P.kwargs) -> _R: self.globals["label_name"] = hassfunction(label_name) self.filters["label_name"] = self.globals["label_name"] + self.globals["label_description"] = hassfunction(label_description) + self.filters["label_description"] = self.globals["label_description"] + self.globals["label_areas"] = hassfunction(label_areas) self.filters["label_areas"] = self.globals["label_areas"] diff --git a/tests/helpers/test_template.py b/tests/helpers/test_template.py index 8e6e7643df39d7..15c6a4b7251895 100644 --- a/tests/helpers/test_template.py +++ b/tests/helpers/test_template.py @@ -6295,6 +6295,40 @@ async def test_label_name( assert info.rate_limit is None +async def test_label_description( + hass: HomeAssistant, + label_registry: lr.LabelRegistry, +) -> None: + """Test label_description function.""" + # Test non existing label ID + info = render_to_info(hass, "{{ label_description('1234567890') }}") + assert_result_info(info, None) + assert info.rate_limit is None + + info = render_to_info(hass, "{{ '1234567890' | label_description }}") + assert_result_info(info, None) + assert info.rate_limit is None + + # Test wrong value type + info = render_to_info(hass, "{{ label_description(42) }}") + assert_result_info(info, None) + assert info.rate_limit is None + + info = render_to_info(hass, "{{ 42 | label_description }}") + assert_result_info(info, None) + assert info.rate_limit is None + + # Test valid label ID + label = label_registry.async_create("choo choo", description="chugga chugga") + info = render_to_info(hass, f"{{{{ label_description('{label.label_id}') }}}}") + assert_result_info(info, label.description) + assert info.rate_limit is None + + info = render_to_info(hass, f"{{{{ '{label.label_id}' | label_description }}}}") + assert_result_info(info, label.description) + assert info.rate_limit is None + + async def test_label_entities( hass: HomeAssistant, entity_registry: er.EntityRegistry, From 673a2e35adf8b2277f86305c7e0da886133f1121 Mon Sep 17 00:00:00 2001 From: Marcel van der Veldt Date: Mon, 23 Jun 2025 20:39:46 +0200 Subject: [PATCH 14/30] Add button entity to Music Assistant to add currently playing item to favorites (#145626) * Add action to Music Assistant to add currently playing item to favorites * add test * Convert to button entity * review comments * Update test_button.ambr * Fix --------- Co-authored-by: Joost Lekkerkerker Co-authored-by: Robert Resch --- .../components/music_assistant/__init__.py | 35 ++++- .../components/music_assistant/button.py | 53 +++++++ .../components/music_assistant/helpers.py | 28 ++++ .../components/music_assistant/icons.json | 7 + .../music_assistant/media_player.py | 61 ++------ .../components/music_assistant/strings.json | 7 + .../snapshots/test_button.ambr | 145 ++++++++++++++++++ .../components/music_assistant/test_button.py | 48 ++++++ 8 files changed, 332 insertions(+), 52 deletions(-) create mode 100644 homeassistant/components/music_assistant/button.py create mode 100644 homeassistant/components/music_assistant/helpers.py create mode 100644 tests/components/music_assistant/snapshots/test_button.ambr create mode 100644 tests/components/music_assistant/test_button.py diff --git a/homeassistant/components/music_assistant/__init__.py b/homeassistant/components/music_assistant/__init__.py index a2d2dae9e3f9b5..32024c5ad1399a 100644 --- a/homeassistant/components/music_assistant/__init__.py +++ b/homeassistant/components/music_assistant/__init__.py @@ -3,7 +3,8 @@ from __future__ import annotations import asyncio -from dataclasses import dataclass +from collections.abc import Callable +from dataclasses import dataclass, field from typing import TYPE_CHECKING from music_assistant_client import MusicAssistantClient @@ -31,7 +32,7 @@ from homeassistant.helpers.typing import ConfigType -PLATFORMS = [Platform.MEDIA_PLAYER] +PLATFORMS = [Platform.BUTTON, Platform.MEDIA_PLAYER] CONNECT_TIMEOUT = 10 LISTEN_READY_TIMEOUT = 30 @@ -39,6 +40,7 @@ CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN) type MusicAssistantConfigEntry = ConfigEntry[MusicAssistantEntryData] +type PlayerAddCallback = Callable[[str], None] @dataclass @@ -47,6 +49,8 @@ class MusicAssistantEntryData: mass: MusicAssistantClient listen_task: asyncio.Task + discovered_players: set[str] = field(default_factory=set) + platform_handlers: dict[Platform, PlayerAddCallback] = field(default_factory=dict) async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: @@ -122,6 +126,33 @@ async def on_hass_stop(event: Event) -> None: # initialize platforms await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) + # register listener for new players + async def handle_player_added(event: MassEvent) -> None: + """Handle Mass Player Added event.""" + if TYPE_CHECKING: + assert event.object_id is not None + if event.object_id in entry.runtime_data.discovered_players: + return + player = mass.players.get(event.object_id) + if TYPE_CHECKING: + assert player is not None + if not player.expose_to_ha: + return + entry.runtime_data.discovered_players.add(event.object_id) + # run callback for each platform + for callback in entry.runtime_data.platform_handlers.values(): + callback(event.object_id) + + entry.async_on_unload(mass.subscribe(handle_player_added, EventType.PLAYER_ADDED)) + + # add all current players + for player in mass.players: + if not player.expose_to_ha: + continue + entry.runtime_data.discovered_players.add(player.player_id) + for callback in entry.runtime_data.platform_handlers.values(): + callback(player.player_id) + # register listener for removed players async def handle_player_removed(event: MassEvent) -> None: """Handle Mass Player Removed event.""" diff --git a/homeassistant/components/music_assistant/button.py b/homeassistant/components/music_assistant/button.py new file mode 100644 index 00000000000000..7969954e443dd0 --- /dev/null +++ b/homeassistant/components/music_assistant/button.py @@ -0,0 +1,53 @@ +"""Music Assistant Button platform.""" + +from __future__ import annotations + +from homeassistant.components.button import ButtonEntity, ButtonEntityDescription +from homeassistant.const import Platform +from homeassistant.core import HomeAssistant +from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback + +from . import MusicAssistantConfigEntry +from .entity import MusicAssistantEntity +from .helpers import catch_musicassistant_error + + +async def async_setup_entry( + hass: HomeAssistant, + entry: MusicAssistantConfigEntry, + async_add_entities: AddConfigEntryEntitiesCallback, +) -> None: + """Set up Music Assistant MediaPlayer(s) from Config Entry.""" + mass = entry.runtime_data.mass + + def add_player(player_id: str) -> None: + """Handle add player.""" + async_add_entities( + [ + # Add button entity to favorite the currently playing item on the player + MusicAssistantFavoriteButton(mass, player_id) + ] + ) + + # register callback to add players when they are discovered + entry.runtime_data.platform_handlers.setdefault(Platform.BUTTON, add_player) + + +class MusicAssistantFavoriteButton(MusicAssistantEntity, ButtonEntity): + """Representation of a Button entity to favorite the currently playing item on a player.""" + + entity_description = ButtonEntityDescription( + key="favorite_now_playing", + translation_key="favorite_now_playing", + ) + + @property + def available(self) -> bool: + """Return availability of entity.""" + # mark the button as unavailable if the player has no current media item + return super().available and self.player.current_media is not None + + @catch_musicassistant_error + async def async_press(self) -> None: + """Handle the button press command.""" + await self.mass.players.add_currently_playing_to_favorites(self.player_id) diff --git a/homeassistant/components/music_assistant/helpers.py b/homeassistant/components/music_assistant/helpers.py new file mode 100644 index 00000000000000..b228e99f76f3c2 --- /dev/null +++ b/homeassistant/components/music_assistant/helpers.py @@ -0,0 +1,28 @@ +"""Helpers for the Music Assistant integration.""" + +from __future__ import annotations + +from collections.abc import Callable, Coroutine +import functools +from typing import Any + +from music_assistant_models.errors import MusicAssistantError + +from homeassistant.exceptions import HomeAssistantError + + +def catch_musicassistant_error[**_P, _R]( + func: Callable[_P, Coroutine[Any, Any, _R]], +) -> Callable[_P, Coroutine[Any, Any, _R]]: + """Check and convert commands to players.""" + + @functools.wraps(func) + async def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R: + """Catch Music Assistant errors and convert to Home Assistant error.""" + try: + return await func(*args, **kwargs) + except MusicAssistantError as err: + error_msg = str(err) or err.__class__.__name__ + raise HomeAssistantError(error_msg) from err + + return wrapper diff --git a/homeassistant/components/music_assistant/icons.json b/homeassistant/components/music_assistant/icons.json index 0fa64b8d273fa7..24c6eb2a20294e 100644 --- a/homeassistant/components/music_assistant/icons.json +++ b/homeassistant/components/music_assistant/icons.json @@ -1,4 +1,11 @@ { + "entity": { + "button": { + "favorite_now_playing": { + "default": "mdi:heart-plus" + } + } + }, "services": { "play_media": { "service": "mdi:play" }, "play_announcement": { "service": "mdi:bullhorn" }, diff --git a/homeassistant/components/music_assistant/media_player.py b/homeassistant/components/music_assistant/media_player.py index a11e334824ad29..8d4e69bf082754 100644 --- a/homeassistant/components/music_assistant/media_player.py +++ b/homeassistant/components/music_assistant/media_player.py @@ -3,11 +3,10 @@ from __future__ import annotations import asyncio -from collections.abc import Callable, Coroutine, Mapping +from collections.abc import Mapping from contextlib import suppress -import functools import os -from typing import TYPE_CHECKING, Any, Concatenate +from typing import TYPE_CHECKING, Any from music_assistant_models.constants import PLAYER_CONTROL_NONE from music_assistant_models.enums import ( @@ -18,7 +17,7 @@ QueueOption, RepeatMode as MassRepeatMode, ) -from music_assistant_models.errors import MediaNotFoundError, MusicAssistantError +from music_assistant_models.errors import MediaNotFoundError from music_assistant_models.event import MassEvent from music_assistant_models.media_items import ItemMapping, MediaItemType, Track from music_assistant_models.player_queue import PlayerQueue @@ -40,7 +39,7 @@ SearchMediaQuery, async_process_play_media_url, ) -from homeassistant.const import ATTR_NAME, STATE_OFF +from homeassistant.const import ATTR_NAME, STATE_OFF, Platform from homeassistant.core import HomeAssistant, ServiceResponse, SupportsResponse from homeassistant.exceptions import HomeAssistantError, ServiceValidationError from homeassistant.helpers import config_validation as cv, entity_registry as er @@ -76,6 +75,7 @@ DOMAIN, ) from .entity import MusicAssistantEntity +from .helpers import catch_musicassistant_error from .media_browser import async_browse_media, async_search_media from .schemas import QUEUE_DETAILS_SCHEMA, queue_item_dict_from_mass_item @@ -120,25 +120,6 @@ SERVICE_GET_QUEUE = "get_queue" -def catch_musicassistant_error[_R, **P]( - func: Callable[Concatenate[MusicAssistantPlayer, P], Coroutine[Any, Any, _R]], -) -> Callable[Concatenate[MusicAssistantPlayer, P], Coroutine[Any, Any, _R]]: - """Check and log commands to players.""" - - @functools.wraps(func) - async def wrapper( - self: MusicAssistantPlayer, *args: P.args, **kwargs: P.kwargs - ) -> _R: - """Catch Music Assistant errors and convert to Home Assistant error.""" - try: - return await func(self, *args, **kwargs) - except MusicAssistantError as err: - error_msg = str(err) or err.__class__.__name__ - raise HomeAssistantError(error_msg) from err - - return wrapper - - async def async_setup_entry( hass: HomeAssistant, entry: MusicAssistantConfigEntry, @@ -146,33 +127,13 @@ async def async_setup_entry( ) -> None: """Set up Music Assistant MediaPlayer(s) from Config Entry.""" mass = entry.runtime_data.mass - added_ids = set() - async def handle_player_added(event: MassEvent) -> None: - """Handle Mass Player Added event.""" - if TYPE_CHECKING: - assert event.object_id is not None - if event.object_id in added_ids: - return - player = mass.players.get(event.object_id) - if TYPE_CHECKING: - assert player is not None - if not player.expose_to_ha: - return - added_ids.add(event.object_id) - async_add_entities([MusicAssistantPlayer(mass, event.object_id)]) - - # register listener for new players - entry.async_on_unload(mass.subscribe(handle_player_added, EventType.PLAYER_ADDED)) - mass_players = [] - # add all current players - for player in mass.players: - if not player.expose_to_ha: - continue - added_ids.add(player.player_id) - mass_players.append(MusicAssistantPlayer(mass, player.player_id)) - - async_add_entities(mass_players) + def add_player(player_id: str) -> None: + """Handle add player.""" + async_add_entities([MusicAssistantPlayer(mass, player_id)]) + + # register callback to add players when they are discovered + entry.runtime_data.platform_handlers.setdefault(Platform.MEDIA_PLAYER, add_player) # add platform service for play_media with advanced options platform = async_get_current_platform() diff --git a/homeassistant/components/music_assistant/strings.json b/homeassistant/components/music_assistant/strings.json index c7e7baf88f6c63..c41bfa70d4c945 100644 --- a/homeassistant/components/music_assistant/strings.json +++ b/homeassistant/components/music_assistant/strings.json @@ -31,6 +31,13 @@ "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]" } }, + "entity": { + "button": { + "favorite_now_playing": { + "name": "Favorite current song" + } + } + }, "issues": { "invalid_server_version": { "title": "The Music Assistant server is not the correct version", diff --git a/tests/components/music_assistant/snapshots/test_button.ambr b/tests/components/music_assistant/snapshots/test_button.ambr new file mode 100644 index 00000000000000..ac9e4c660f6857 --- /dev/null +++ b/tests/components/music_assistant/snapshots/test_button.ambr @@ -0,0 +1,145 @@ +# serializer version: 1 +# name: test_button_entities[button.my_super_test_player_2_favorite_current_song-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'button', + 'entity_category': None, + 'entity_id': 'button.my_super_test_player_2_favorite_current_song', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Favorite current song', + 'platform': 'music_assistant', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'favorite_now_playing', + 'unique_id': '00:00:00:00:00:02_favorite_now_playing', + 'unit_of_measurement': None, + }) +# --- +# name: test_button_entities[button.my_super_test_player_2_favorite_current_song-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'My Super Test Player 2 Favorite current song', + }), + 'context': , + 'entity_id': 'button.my_super_test_player_2_favorite_current_song', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'unknown', + }) +# --- +# name: test_button_entities[button.test_group_player_1_favorite_current_song-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'button', + 'entity_category': None, + 'entity_id': 'button.test_group_player_1_favorite_current_song', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Favorite current song', + 'platform': 'music_assistant', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'favorite_now_playing', + 'unique_id': 'test_group_player_1_favorite_now_playing', + 'unit_of_measurement': None, + }) +# --- +# name: test_button_entities[button.test_group_player_1_favorite_current_song-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Test Group Player 1 Favorite current song', + }), + 'context': , + 'entity_id': 'button.test_group_player_1_favorite_current_song', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'unknown', + }) +# --- +# name: test_button_entities[button.test_player_1_favorite_current_song-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'button', + 'entity_category': None, + 'entity_id': 'button.test_player_1_favorite_current_song', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Favorite current song', + 'platform': 'music_assistant', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'favorite_now_playing', + 'unique_id': '00:00:00:00:00:01_favorite_now_playing', + 'unit_of_measurement': None, + }) +# --- +# name: test_button_entities[button.test_player_1_favorite_current_song-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Test Player 1 Favorite current song', + }), + 'context': , + 'entity_id': 'button.test_player_1_favorite_current_song', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'unavailable', + }) +# --- diff --git a/tests/components/music_assistant/test_button.py b/tests/components/music_assistant/test_button.py new file mode 100644 index 00000000000000..8a1a4b0e241ade --- /dev/null +++ b/tests/components/music_assistant/test_button.py @@ -0,0 +1,48 @@ +"""Test Music Assistant button entities.""" + +from unittest.mock import MagicMock, call + +from syrupy.assertion import SnapshotAssertion + +from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS +from homeassistant.const import ATTR_ENTITY_ID, Platform +from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er + +from .common import setup_integration_from_fixtures, snapshot_music_assistant_entities + + +async def test_button_entities( + hass: HomeAssistant, + entity_registry: er.EntityRegistry, + snapshot: SnapshotAssertion, + music_assistant_client: MagicMock, +) -> None: + """Test media player.""" + await setup_integration_from_fixtures(hass, music_assistant_client) + snapshot_music_assistant_entities(hass, entity_registry, snapshot, Platform.BUTTON) + + +async def test_button_press_action( + hass: HomeAssistant, + music_assistant_client: MagicMock, +) -> None: + """Test button press action.""" + await setup_integration_from_fixtures(hass, music_assistant_client) + entity_id = "button.my_super_test_player_2_favorite_current_song" + state = hass.states.get(entity_id) + assert state + await hass.services.async_call( + BUTTON_DOMAIN, + SERVICE_PRESS, + { + ATTR_ENTITY_ID: entity_id, + }, + blocking=True, + ) + + assert music_assistant_client.send_command.call_count == 1 + assert music_assistant_client.send_command.call_args == call( + "music/favorites/add_item", + item="spotify://track/5d95dc5be77e4f7eb4939f62cfef527b", + ) From 3806e5b65c2dd02e6de27fa8bdfe541dffcdbcbb Mon Sep 17 00:00:00 2001 From: Matthias Alphart Date: Mon, 23 Jun 2025 20:41:00 +0200 Subject: [PATCH 15/30] Set KNX to quality scale "silver" (#144879) Update KNX integration quality scale --- homeassistant/components/knx/manifest.json | 1 + homeassistant/components/knx/quality_scale.yaml | 17 ++++++++++------- script/hassfest/quality_scale.py | 1 - 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/homeassistant/components/knx/manifest.json b/homeassistant/components/knx/manifest.json index 36c4bc712737d2..baa830bfaa47d6 100644 --- a/homeassistant/components/knx/manifest.json +++ b/homeassistant/components/knx/manifest.json @@ -9,6 +9,7 @@ "integration_type": "hub", "iot_class": "local_push", "loggers": ["xknx", "xknxproject"], + "quality_scale": "silver", "requirements": [ "xknx==3.8.0", "xknxproject==3.8.2", diff --git a/homeassistant/components/knx/quality_scale.yaml b/homeassistant/components/knx/quality_scale.yaml index 63aa4578159f26..b4b36213c43cd7 100644 --- a/homeassistant/components/knx/quality_scale.yaml +++ b/homeassistant/components/knx/quality_scale.yaml @@ -13,7 +13,7 @@ rules: docs-actions: done docs-high-level-description: done docs-installation-instructions: done - docs-removal-instructions: todo + docs-removal-instructions: done entity-event-setup: done entity-unique-id: done has-entity-name: @@ -41,8 +41,8 @@ rules: # Silver action-exceptions: done config-entry-unloading: done - docs-configuration-parameters: todo - docs-installation-parameters: todo + docs-configuration-parameters: done + docs-installation-parameters: done entity-unavailable: done integration-owner: done log-when-unavailable: @@ -64,21 +64,24 @@ rules: comment: | YAML entities don't support devices. UI entities support user-defined devices. diagnostics: done - discovery-update-info: todo + discovery-update-info: + status: exempt + comment: | + KNX doesn't support any provided discovery method. discovery: status: exempt comment: | KNX doesn't support any provided discovery method. - docs-data-update: todo + docs-data-update: done docs-examples: done - docs-known-limitations: todo + docs-known-limitations: done docs-supported-devices: status: exempt comment: | Devices aren't supported directly since communication is on group address level. docs-supported-functions: done docs-troubleshooting: done - docs-use-cases: todo + docs-use-cases: done dynamic-devices: status: exempt comment: | diff --git a/script/hassfest/quality_scale.py b/script/hassfest/quality_scale.py index 52e5f9351176ce..73505e805bc3d2 100644 --- a/script/hassfest/quality_scale.py +++ b/script/hassfest/quality_scale.py @@ -1607,7 +1607,6 @@ class Rule: "konnected", "kostal_plenticore", "kraken", - "knx", "kulersky", "kwb", "lacrosse", From 2862f76fca4476bec3546962e473f9b467775032 Mon Sep 17 00:00:00 2001 From: starkillerOG Date: Mon, 23 Jun 2025 20:43:01 +0200 Subject: [PATCH 16/30] Add support for Reolink Floodlight PoE/WiFi (#146778) * Add support for Floodlight PoE/WiFi * Adjust test * Add test --- homeassistant/components/reolink/__init__.py | 3 + .../components/reolink/config_flow.py | 9 ++- homeassistant/components/reolink/const.py | 1 + homeassistant/components/reolink/host.py | 16 ++++- tests/components/reolink/conftest.py | 2 + tests/components/reolink/test_config_flow.py | 59 +++++++++++++++++++ 6 files changed, 86 insertions(+), 4 deletions(-) diff --git a/homeassistant/components/reolink/__init__.py b/homeassistant/components/reolink/__init__.py index 38445b912bc7b6..3260bff44b5ef3 100644 --- a/homeassistant/components/reolink/__init__.py +++ b/homeassistant/components/reolink/__init__.py @@ -32,6 +32,7 @@ from .const import ( BATTERY_PASSIVE_WAKE_UPDATE_INTERVAL, + CONF_BC_ONLY, CONF_BC_PORT, CONF_SUPPORTS_PRIVACY_MODE, CONF_USE_HTTPS, @@ -107,6 +108,7 @@ async def async_setup_entry( or host.api.supported(None, "privacy_mode") != config_entry.data.get(CONF_SUPPORTS_PRIVACY_MODE) or host.api.baichuan.port != config_entry.data.get(CONF_BC_PORT) + or host.api.baichuan_only != config_entry.data.get(CONF_BC_ONLY) ): if host.api.port != config_entry.data[CONF_PORT]: _LOGGER.warning( @@ -130,6 +132,7 @@ async def async_setup_entry( CONF_PORT: host.api.port, CONF_USE_HTTPS: host.api.use_https, CONF_BC_PORT: host.api.baichuan.port, + CONF_BC_ONLY: host.api.baichuan_only, CONF_SUPPORTS_PRIVACY_MODE: host.api.supported(None, "privacy_mode"), } hass.config_entries.async_update_entry(config_entry, data=data) diff --git a/homeassistant/components/reolink/config_flow.py b/homeassistant/components/reolink/config_flow.py index 659169c3618763..eee8b04dfccfed 100644 --- a/homeassistant/components/reolink/config_flow.py +++ b/homeassistant/components/reolink/config_flow.py @@ -38,7 +38,13 @@ from homeassistant.helpers.device_registry import format_mac from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo -from .const import CONF_BC_PORT, CONF_SUPPORTS_PRIVACY_MODE, CONF_USE_HTTPS, DOMAIN +from .const import ( + CONF_BC_ONLY, + CONF_BC_PORT, + CONF_SUPPORTS_PRIVACY_MODE, + CONF_USE_HTTPS, + DOMAIN, +) from .exceptions import ( PasswordIncompatible, ReolinkException, @@ -296,6 +302,7 @@ async def async_step_user( user_input[CONF_PORT] = host.api.port user_input[CONF_USE_HTTPS] = host.api.use_https user_input[CONF_BC_PORT] = host.api.baichuan.port + user_input[CONF_BC_ONLY] = host.api.baichuan_only user_input[CONF_SUPPORTS_PRIVACY_MODE] = host.api.supported( None, "privacy_mode" ) diff --git a/homeassistant/components/reolink/const.py b/homeassistant/components/reolink/const.py index bd9c4bb84a2558..db2d105984be96 100644 --- a/homeassistant/components/reolink/const.py +++ b/homeassistant/components/reolink/const.py @@ -4,6 +4,7 @@ CONF_USE_HTTPS = "use_https" CONF_BC_PORT = "baichuan_port" +CONF_BC_ONLY = "baichuan_only" CONF_SUPPORTS_PRIVACY_MODE = "privacy_mode_supported" # Conserve battery by not waking the battery cameras each minute during normal update diff --git a/homeassistant/components/reolink/host.py b/homeassistant/components/reolink/host.py index 39b58c92ac35f1..0f64dc059020d8 100644 --- a/homeassistant/components/reolink/host.py +++ b/homeassistant/components/reolink/host.py @@ -38,6 +38,7 @@ BATTERY_ALL_WAKE_UPDATE_INTERVAL, BATTERY_PASSIVE_WAKE_UPDATE_INTERVAL, BATTERY_WAKE_UPDATE_INTERVAL, + CONF_BC_ONLY, CONF_BC_PORT, CONF_SUPPORTS_PRIVACY_MODE, CONF_USE_HTTPS, @@ -97,6 +98,7 @@ def get_aiohttp_session() -> aiohttp.ClientSession: timeout=DEFAULT_TIMEOUT, aiohttp_get_session_callback=get_aiohttp_session, bc_port=config.get(CONF_BC_PORT, DEFAULT_BC_PORT), + bc_only=config.get(CONF_BC_ONLY, False), ) self.last_wake: defaultdict[int, float] = defaultdict(float) @@ -220,19 +222,27 @@ async def async_init(self) -> None: enable_onvif = None enable_rtmp = None - if not self._api.rtsp_enabled: + if not self._api.rtsp_enabled and not self._api.baichuan_only: _LOGGER.debug( "RTSP is disabled on %s, trying to enable it", self._api.nvr_name ) enable_rtsp = True - if not self._api.onvif_enabled and onvif_supported: + if ( + not self._api.onvif_enabled + and onvif_supported + and not self._api.baichuan_only + ): _LOGGER.debug( "ONVIF is disabled on %s, trying to enable it", self._api.nvr_name ) enable_onvif = True - if not self._api.rtmp_enabled and self._api.protocol == "rtmp": + if ( + not self._api.rtmp_enabled + and self._api.protocol == "rtmp" + and not self._api.baichuan_only + ): _LOGGER.debug( "RTMP is disabled on %s, trying to enable it", self._api.nvr_name ) diff --git a/tests/components/reolink/conftest.py b/tests/components/reolink/conftest.py index 0ca5612f8fdbae..2f37fca251a230 100644 --- a/tests/components/reolink/conftest.py +++ b/tests/components/reolink/conftest.py @@ -10,6 +10,7 @@ from homeassistant.components.reolink.config_flow import DEFAULT_PROTOCOL from homeassistant.components.reolink.const import ( + CONF_BC_ONLY, CONF_BC_PORT, CONF_SUPPORTS_PRIVACY_MODE, CONF_USE_HTTPS, @@ -219,6 +220,7 @@ def config_entry(hass: HomeAssistant) -> MockConfigEntry: CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_SUPPORTS_PRIVACY_MODE: TEST_PRIVACY, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, diff --git a/tests/components/reolink/test_config_flow.py b/tests/components/reolink/test_config_flow.py index e706af0d067620..4b116929ac81c7 100644 --- a/tests/components/reolink/test_config_flow.py +++ b/tests/components/reolink/test_config_flow.py @@ -19,6 +19,7 @@ from homeassistant.components.reolink import DEVICE_UPDATE_INTERVAL from homeassistant.components.reolink.config_flow import DEFAULT_PROTOCOL from homeassistant.components.reolink.const import ( + CONF_BC_ONLY, CONF_BC_PORT, CONF_SUPPORTS_PRIVACY_MODE, CONF_USE_HTTPS, @@ -91,6 +92,7 @@ async def test_config_flow_manual_success( CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_SUPPORTS_PRIVACY_MODE: TEST_PRIVACY, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, } assert result["options"] == { CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -144,6 +146,7 @@ async def test_config_flow_privacy_success( CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_SUPPORTS_PRIVACY_MODE: TEST_PRIVACY, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, } assert result["options"] == { CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -153,6 +156,49 @@ async def test_config_flow_privacy_success( reolink_connect.baichuan.privacy_mode.return_value = False +async def test_config_flow_baichuan_only( + hass: HomeAssistant, reolink_connect: MagicMock, mock_setup_entry: MagicMock +) -> None: + """Successful flow manually initialized by the user for baichuan only device.""" + reolink_connect.baichuan_only = True + + result = await hass.config_entries.flow.async_init( + DOMAIN, context={"source": config_entries.SOURCE_USER} + ) + + assert result["type"] is FlowResultType.FORM + assert result["step_id"] == "user" + assert result["errors"] == {} + + result = await hass.config_entries.flow.async_configure( + result["flow_id"], + { + CONF_USERNAME: TEST_USERNAME, + CONF_PASSWORD: TEST_PASSWORD, + CONF_HOST: TEST_HOST, + }, + ) + + assert result["type"] is FlowResultType.CREATE_ENTRY + assert result["title"] == TEST_NVR_NAME + assert result["data"] == { + CONF_HOST: TEST_HOST, + CONF_USERNAME: TEST_USERNAME, + CONF_PASSWORD: TEST_PASSWORD, + CONF_PORT: TEST_PORT, + CONF_USE_HTTPS: TEST_USE_HTTPS, + CONF_SUPPORTS_PRIVACY_MODE: TEST_PRIVACY, + CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: True, + } + assert result["options"] == { + CONF_PROTOCOL: DEFAULT_PROTOCOL, + } + assert result["result"].unique_id == TEST_MAC + + reolink_connect.baichuan_only = False + + async def test_config_flow_errors( hass: HomeAssistant, reolink_connect: MagicMock, mock_setup_entry: MagicMock ) -> None: @@ -308,6 +354,7 @@ async def test_config_flow_errors( CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_SUPPORTS_PRIVACY_MODE: TEST_PRIVACY, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, } assert result["options"] == { CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -329,6 +376,7 @@ async def test_options_flow(hass: HomeAssistant, mock_setup_entry: MagicMock) -> CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: "rtsp", @@ -368,6 +416,7 @@ async def test_reauth(hass: HomeAssistant, mock_setup_entry: MagicMock) -> None: CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -414,6 +463,7 @@ async def test_reauth_abort_unique_id_mismatch( CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -484,6 +534,7 @@ async def test_dhcp_flow(hass: HomeAssistant, mock_setup_entry: MagicMock) -> No CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_SUPPORTS_PRIVACY_MODE: TEST_PRIVACY, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, } assert result["options"] == { CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -507,6 +558,7 @@ async def test_dhcp_ip_update_aborted_if_wrong_mac( CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -548,6 +600,7 @@ async def test_dhcp_ip_update_aborted_if_wrong_mac( timeout=DEFAULT_TIMEOUT, aiohttp_get_session_callback=ANY, bc_port=TEST_BC_PORT, + bc_only=False, ) assert expected_call in reolink_connect_class.call_args_list @@ -606,6 +659,7 @@ async def test_dhcp_ip_update( CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -649,6 +703,7 @@ async def test_dhcp_ip_update( timeout=DEFAULT_TIMEOUT, aiohttp_get_session_callback=ANY, bc_port=TEST_BC_PORT, + bc_only=False, ) assert expected_call in reolink_connect_class.call_args_list @@ -686,6 +741,7 @@ async def test_dhcp_ip_update_ingnored_if_still_connected( CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -718,6 +774,7 @@ async def test_dhcp_ip_update_ingnored_if_still_connected( timeout=DEFAULT_TIMEOUT, aiohttp_get_session_callback=ANY, bc_port=TEST_BC_PORT, + bc_only=False, ) assert expected_call in reolink_connect_class.call_args_list @@ -748,6 +805,7 @@ async def test_reconfig(hass: HomeAssistant, mock_setup_entry: MagicMock) -> Non CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, @@ -795,6 +853,7 @@ async def test_reconfig_abort_unique_id_mismatch( CONF_PORT: TEST_PORT, CONF_USE_HTTPS: TEST_USE_HTTPS, CONF_BC_PORT: TEST_BC_PORT, + CONF_BC_ONLY: False, }, options={ CONF_PROTOCOL: DEFAULT_PROTOCOL, From b4af9a31cb13c6f58c624a53230cb2587ac55ada Mon Sep 17 00:00:00 2001 From: starkillerOG Date: Mon, 23 Jun 2025 20:44:35 +0200 Subject: [PATCH 17/30] Add multiple cmd_id pushes for Reolink floodlight (#146685) Allow for multiple cmd_id pushes --- homeassistant/components/reolink/entity.py | 11 +++++++---- homeassistant/components/reolink/light.py | 2 +- homeassistant/components/reolink/number.py | 1 + 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/homeassistant/components/reolink/entity.py b/homeassistant/components/reolink/entity.py index 467472fef9c900..a83dc259e1bc6e 100644 --- a/homeassistant/components/reolink/entity.py +++ b/homeassistant/components/reolink/entity.py @@ -24,7 +24,7 @@ class ReolinkEntityDescription(EntityDescription): """A class that describes entities for Reolink.""" cmd_key: str | None = None - cmd_id: int | None = None + cmd_id: int | list[int] | None = None always_available: bool = False @@ -120,12 +120,15 @@ async def async_added_to_hass(self) -> None: """Entity created.""" await super().async_added_to_hass() cmd_key = self.entity_description.cmd_key - cmd_id = self.entity_description.cmd_id + cmd_ids = self.entity_description.cmd_id callback_id = f"{self.platform.domain}_{self._attr_unique_id}" if cmd_key is not None: self._host.async_register_update_cmd(cmd_key) - if cmd_id is not None: - self.register_callback(callback_id, cmd_id) + if isinstance(cmd_ids, int): + self.register_callback(callback_id, cmd_ids) + elif isinstance(cmd_ids, list): + for cmd_id in cmd_ids: + self.register_callback(callback_id, cmd_id) # Privacy mode self.register_callback(f"{callback_id}_623", 623) diff --git a/homeassistant/components/reolink/light.py b/homeassistant/components/reolink/light.py index d48790264d1975..1e2c6d49528f4c 100644 --- a/homeassistant/components/reolink/light.py +++ b/homeassistant/components/reolink/light.py @@ -57,7 +57,7 @@ class ReolinkHostLightEntityDescription( ReolinkLightEntityDescription( key="floodlight", cmd_key="GetWhiteLed", - cmd_id=291, + cmd_id=[291, 289, 438], translation_key="floodlight", supported=lambda api, ch: api.supported(ch, "floodLight"), is_on_fn=lambda api, ch: api.whiteled_state(ch), diff --git a/homeassistant/components/reolink/number.py b/homeassistant/components/reolink/number.py index 6de702a03953d4..2de2468ca3d0a9 100644 --- a/homeassistant/components/reolink/number.py +++ b/homeassistant/components/reolink/number.py @@ -113,6 +113,7 @@ class ReolinkChimeNumberEntityDescription( ReolinkNumberEntityDescription( key="floodlight_brightness", cmd_key="GetWhiteLed", + cmd_id=[289, 438], translation_key="floodlight_brightness", entity_category=EntityCategory.CONFIG, native_step=1, From dd3d6f116ec916acc42c9ff2eec53266d003286d Mon Sep 17 00:00:00 2001 From: starkillerOG Date: Mon, 23 Jun 2025 20:45:24 +0200 Subject: [PATCH 18/30] Rename second Reolink lens from "autotrack" to "telephoto" (#146898) * Rename second Reolink lens from "autotrack" to "telephoto" * Adjust tests --- homeassistant/components/reolink/camera.py | 8 ++++---- homeassistant/components/reolink/media_source.py | 8 ++++---- homeassistant/components/reolink/strings.json | 12 ++++++------ tests/components/reolink/test_media_source.py | 4 ++-- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/homeassistant/components/reolink/camera.py b/homeassistant/components/reolink/camera.py index 119fb625349e52..b9744f8e002edf 100644 --- a/homeassistant/components/reolink/camera.py +++ b/homeassistant/components/reolink/camera.py @@ -69,21 +69,21 @@ class ReolinkCameraEntityDescription( ), ReolinkCameraEntityDescription( key="autotrack_sub", - stream="autotrack_sub", - translation_key="autotrack_sub", + stream="telephoto_sub", + translation_key="telephoto_sub", supported=lambda api, ch: api.supported(ch, "autotrack_stream"), ), ReolinkCameraEntityDescription( key="autotrack_snapshots_sub", stream="autotrack_snapshots_sub", - translation_key="autotrack_snapshots_sub", + translation_key="telephoto_snapshots_sub", supported=lambda api, ch: api.supported(ch, "autotrack_stream"), entity_registry_enabled_default=False, ), ReolinkCameraEntityDescription( key="autotrack_snapshots_main", stream="autotrack_snapshots_main", - translation_key="autotrack_snapshots_main", + translation_key="telephoto_snapshots_main", supported=lambda api, ch: api.supported(ch, "autotrack_stream"), entity_registry_enabled_default=False, ), diff --git a/homeassistant/components/reolink/media_source.py b/homeassistant/components/reolink/media_source.py index 36a2f3c5489584..9c8c685d898fa4 100644 --- a/homeassistant/components/reolink/media_source.py +++ b/homeassistant/components/reolink/media_source.py @@ -42,9 +42,9 @@ def res_name(stream: str) -> str: case "main": return "High res." case "autotrack_sub": - return "Autotrack low res." + return "Telephoto low res." case "autotrack_main": - return "Autotrack high res." + return "Telephoto high res." case _: return "Low res." @@ -284,7 +284,7 @@ async def _async_generate_resolution_select( identifier=f"RES|{config_entry_id}|{channel}|autotrack_sub", media_class=MediaClass.CHANNEL, media_content_type=MediaType.PLAYLIST, - title="Autotrack low resolution", + title="Telephoto low resolution", can_play=False, can_expand=True, ), @@ -293,7 +293,7 @@ async def _async_generate_resolution_select( identifier=f"RES|{config_entry_id}|{channel}|autotrack_main", media_class=MediaClass.CHANNEL, media_content_type=MediaType.PLAYLIST, - title="Autotrack high resolution", + title="Telephoto high resolution", can_play=False, can_expand=True, ), diff --git a/homeassistant/components/reolink/strings.json b/homeassistant/components/reolink/strings.json index e7a970ec1c8b6a..7a77c523b16c73 100644 --- a/homeassistant/components/reolink/strings.json +++ b/homeassistant/components/reolink/strings.json @@ -504,14 +504,14 @@ "ext_lens_1": { "name": "Balanced lens 1" }, - "autotrack_sub": { - "name": "Autotrack fluent" + "telephoto_sub": { + "name": "Telephoto fluent" }, - "autotrack_snapshots_sub": { - "name": "Autotrack snapshots fluent" + "telephoto_snapshots_sub": { + "name": "Telephoto snapshots fluent" }, - "autotrack_snapshots_main": { - "name": "Autotrack snapshots clear" + "telephoto_snapshots_main": { + "name": "Telephoto snapshots clear" } }, "light": { diff --git a/tests/components/reolink/test_media_source.py b/tests/components/reolink/test_media_source.py index 59f0c6c195d877..67ae78e5fa43d9 100644 --- a/tests/components/reolink/test_media_source.py +++ b/tests/components/reolink/test_media_source.py @@ -194,13 +194,13 @@ async def test_browsing( hass, f"{URI_SCHEME}{DOMAIN}/{browse_res_AT_sub_id}" ) assert browse.domain == DOMAIN - assert browse.title == f"{TEST_NVR_NAME} lens 0 Autotrack low res." + assert browse.title == f"{TEST_NVR_NAME} lens 0 Telephoto low res." browse = await async_browse_media( hass, f"{URI_SCHEME}{DOMAIN}/{browse_res_AT_main_id}" ) assert browse.domain == DOMAIN - assert browse.title == f"{TEST_NVR_NAME} lens 0 Autotrack high res." + assert browse.title == f"{TEST_NVR_NAME} lens 0 Telephoto high res." browse = await async_browse_media( hass, f"{URI_SCHEME}{DOMAIN}/{browse_res_main_id}" From 6af290eb746174b13668d7b04f7d046a0861f36d Mon Sep 17 00:00:00 2001 From: starkillerOG Date: Mon, 23 Jun 2025 20:53:09 +0200 Subject: [PATCH 19/30] Add Reolink Telephoto main stream (#146975) --- homeassistant/components/reolink/camera.py | 7 +++++++ homeassistant/components/reolink/strings.json | 3 +++ 2 files changed, 10 insertions(+) diff --git a/homeassistant/components/reolink/camera.py b/homeassistant/components/reolink/camera.py index b9744f8e002edf..44386434cad320 100644 --- a/homeassistant/components/reolink/camera.py +++ b/homeassistant/components/reolink/camera.py @@ -73,6 +73,13 @@ class ReolinkCameraEntityDescription( translation_key="telephoto_sub", supported=lambda api, ch: api.supported(ch, "autotrack_stream"), ), + ReolinkCameraEntityDescription( + key="autotrack_main", + stream="telephoto_main", + translation_key="telephoto_main", + supported=lambda api, ch: api.supported(ch, "autotrack_stream"), + entity_registry_enabled_default=False, + ), ReolinkCameraEntityDescription( key="autotrack_snapshots_sub", stream="autotrack_snapshots_sub", diff --git a/homeassistant/components/reolink/strings.json b/homeassistant/components/reolink/strings.json index 7a77c523b16c73..5473887a8ffecd 100644 --- a/homeassistant/components/reolink/strings.json +++ b/homeassistant/components/reolink/strings.json @@ -507,6 +507,9 @@ "telephoto_sub": { "name": "Telephoto fluent" }, + "telephoto_main": { + "name": "Telephoto clear" + }, "telephoto_snapshots_sub": { "name": "Telephoto snapshots fluent" }, From fc91047d8d01a51da97857adfeaba5f4a22223c0 Mon Sep 17 00:00:00 2001 From: Alex Biddulph Date: Tue, 24 Jun 2025 04:59:18 +1000 Subject: [PATCH 20/30] Add sensors for detailed Enphase inverter readings (#146916) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Add extra details to Enphase inverters * Bump pyenphase version to 2.1.0 * Add new inverter sensors and translations * Add new endpoint * Start updating tests * Remove duplicate class * Add `max_reported` sensor * Move translation strings to correct location * Update fixtures and snapshots * Update unit tests * Fix linting * Apply suggestions from code review Co-authored-by: Arie Catsman <120491684+catsmanac@users.noreply.github.com> * Fix Telegram bot parsing of inline keyboard (#146376) * bug fix for inline keyboard * update inline keyboard test * Update tests/components/telegram_bot/test_telegram_bot.py Co-authored-by: Martin Hjelmare * revert last_message_id and updated tests * removed TypeError test --------- Co-authored-by: Martin Hjelmare * Handle the new JSON payload from traccar clients (#147254) * Set `entity_id` * Update unit tests * Bump aioamazondevices to 3.1.14 (#147257) * Bump pyseventeentrack to 1.1.1 (#147253) Update pyseventeentrack requirement to version 1.1.1 * Bump uiprotect to version 7.14.1 (#147280) * Fix `state_class`es for energy production * Make `max_reported` `name` more descriptive * Update snapshots * Reuse some translations * Remove unnecessary translation keys * Update unit tests * Update homeassistant/components/enphase_envoy/strings.json * Update homeassistant/components/enphase_envoy/strings.json * Fix --------- Co-authored-by: Arie Catsman <120491684+catsmanac@users.noreply.github.com> Co-authored-by: hanwg Co-authored-by: Martin Hjelmare Co-authored-by: Joakim Sørensen Co-authored-by: Simone Chemelli Co-authored-by: Shai Ungar Co-authored-by: Raphael Hehl <7577984+RaHehl@users.noreply.github.com> Co-authored-by: Joost Lekkerkerker --- .../components/enphase_envoy/diagnostics.py | 1 + .../components/enphase_envoy/manifest.json | 2 +- .../components/enphase_envoy/sensor.py | 109 + .../components/enphase_envoy/strings.json | 27 + requirements_all.txt | 2 +- requirements_test_all.txt | 2 +- .../enphase_envoy/fixtures/envoy.json | 16 +- .../fixtures/envoy_1p_metered.json | 12 +- .../fixtures/envoy_acb_batt.json | 12 +- .../enphase_envoy/fixtures/envoy_eu_batt.json | 12 +- .../fixtures/envoy_metered_batt_relay.json | 12 +- .../fixtures/envoy_nobatt_metered_3p.json | 12 +- .../fixtures/envoy_tot_cons_metered.json | 12 +- .../snapshots/test_diagnostics.ambr | 2763 ++- .../enphase_envoy/snapshots/test_sensor.ambr | 20053 ++++++++++------ tests/components/enphase_envoy/test_init.py | 8 +- tests/components/enphase_envoy/test_sensor.py | 80 +- 17 files changed, 14721 insertions(+), 8414 deletions(-) diff --git a/homeassistant/components/enphase_envoy/diagnostics.py b/homeassistant/components/enphase_envoy/diagnostics.py index e59a9fa09c5a88..a1a9d4ed6b4a34 100644 --- a/homeassistant/components/enphase_envoy/diagnostics.py +++ b/homeassistant/components/enphase_envoy/diagnostics.py @@ -65,6 +65,7 @@ async def _get_fixture_collection(envoy: Envoy, serial: str) -> dict[str, Any]: "/ivp/ensemble/generator", "/ivp/meters", "/ivp/meters/readings", + "/ivp/pdm/device_data", "/home", ] diff --git a/homeassistant/components/enphase_envoy/manifest.json b/homeassistant/components/enphase_envoy/manifest.json index 6f1e0a943ef4d3..5f74da954a06ef 100644 --- a/homeassistant/components/enphase_envoy/manifest.json +++ b/homeassistant/components/enphase_envoy/manifest.json @@ -7,7 +7,7 @@ "iot_class": "local_polling", "loggers": ["pyenphase"], "quality_scale": "platinum", - "requirements": ["pyenphase==2.0.1"], + "requirements": ["pyenphase==2.1.0"], "zeroconf": [ { "type": "_enphase-envoy._tcp.local." diff --git a/homeassistant/components/enphase_envoy/sensor.py b/homeassistant/components/enphase_envoy/sensor.py index 594f5f34088046..c1088252618e38 100644 --- a/homeassistant/components/enphase_envoy/sensor.py +++ b/homeassistant/components/enphase_envoy/sensor.py @@ -45,6 +45,7 @@ UnitOfFrequency, UnitOfPower, UnitOfTemperature, + UnitOfTime, ) from homeassistant.core import HomeAssistant from homeassistant.helpers.device_registry import DeviceInfo @@ -80,6 +81,114 @@ class EnvoyInverterSensorEntityDescription(SensorEntityDescription): device_class=SensorDeviceClass.POWER, value_fn=attrgetter("last_report_watts"), ), + EnvoyInverterSensorEntityDescription( + key="dc_voltage", + translation_key="dc_voltage", + native_unit_of_measurement=UnitOfElectricPotential.VOLT, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.VOLTAGE, + suggested_display_precision=3, + entity_registry_enabled_default=False, + value_fn=attrgetter("dc_voltage"), + ), + EnvoyInverterSensorEntityDescription( + key="dc_current", + translation_key="dc_current", + native_unit_of_measurement=UnitOfElectricCurrent.AMPERE, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.CURRENT, + suggested_display_precision=3, + entity_registry_enabled_default=False, + value_fn=attrgetter("dc_current"), + ), + EnvoyInverterSensorEntityDescription( + key="ac_voltage", + translation_key="ac_voltage", + native_unit_of_measurement=UnitOfElectricPotential.VOLT, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.VOLTAGE, + suggested_display_precision=3, + entity_registry_enabled_default=False, + value_fn=attrgetter("ac_voltage"), + ), + EnvoyInverterSensorEntityDescription( + key="ac_current", + translation_key="ac_current", + native_unit_of_measurement=UnitOfElectricCurrent.AMPERE, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.CURRENT, + suggested_display_precision=3, + entity_registry_enabled_default=False, + value_fn=attrgetter("ac_current"), + ), + EnvoyInverterSensorEntityDescription( + key="ac_frequency", + native_unit_of_measurement=UnitOfFrequency.HERTZ, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.FREQUENCY, + suggested_display_precision=3, + entity_registry_enabled_default=False, + value_fn=attrgetter("ac_frequency"), + ), + EnvoyInverterSensorEntityDescription( + key="temperature", + native_unit_of_measurement=UnitOfTemperature.CELSIUS, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.TEMPERATURE, + suggested_display_precision=3, + entity_registry_enabled_default=False, + entity_category=EntityCategory.DIAGNOSTIC, + value_fn=attrgetter("temperature"), + ), + EnvoyInverterSensorEntityDescription( + key="lifetime_energy", + translation_key="lifetime_energy", + native_unit_of_measurement=UnitOfEnergy.WATT_HOUR, + suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR, + state_class=SensorStateClass.TOTAL_INCREASING, + device_class=SensorDeviceClass.ENERGY, + entity_registry_enabled_default=False, + value_fn=attrgetter("lifetime_energy"), + ), + EnvoyInverterSensorEntityDescription( + key="energy_today", + translation_key="energy_today", + native_unit_of_measurement=UnitOfEnergy.WATT_HOUR, + state_class=SensorStateClass.TOTAL_INCREASING, + device_class=SensorDeviceClass.ENERGY, + entity_registry_enabled_default=False, + value_fn=attrgetter("energy_today"), + ), + EnvoyInverterSensorEntityDescription( + key="last_report_duration", + translation_key="last_report_duration", + native_unit_of_measurement=UnitOfTime.SECONDS, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.DURATION, + entity_registry_enabled_default=False, + entity_category=EntityCategory.DIAGNOSTIC, + value_fn=attrgetter("last_report_duration"), + ), + EnvoyInverterSensorEntityDescription( + key="energy_produced", + translation_key="energy_produced", + native_unit_of_measurement=UnitOfEnergy.MILLIWATT_HOUR, + state_class=SensorStateClass.TOTAL, + device_class=SensorDeviceClass.ENERGY, + suggested_display_precision=3, + entity_registry_enabled_default=False, + value_fn=attrgetter("energy_produced"), + ), + EnvoyInverterSensorEntityDescription( + key="max_reported", + translation_key="max_reported", + native_unit_of_measurement=UnitOfPower.WATT, + state_class=SensorStateClass.MEASUREMENT, + device_class=SensorDeviceClass.POWER, + entity_registry_enabled_default=False, + entity_category=EntityCategory.DIAGNOSTIC, + value_fn=attrgetter("max_report_watts"), + ), EnvoyInverterSensorEntityDescription( key=LAST_REPORTED_KEY, translation_key=LAST_REPORTED_KEY, diff --git a/homeassistant/components/enphase_envoy/strings.json b/homeassistant/components/enphase_envoy/strings.json index e45c746869d254..577def459f1173 100644 --- a/homeassistant/components/enphase_envoy/strings.json +++ b/homeassistant/components/enphase_envoy/strings.json @@ -380,6 +380,33 @@ }, "aggregated_soc": { "name": "Aggregated battery soc" + }, + "dc_voltage": { + "name": "DC voltage" + }, + "dc_current": { + "name": "DC current" + }, + "ac_voltage": { + "name": "AC voltage" + }, + "ac_current": { + "name": "AC current" + }, + "lifetime_energy": { + "name": "Lifetime energy produced" + }, + "energy_today": { + "name": "Energy produced today" + }, + "energy_produced": { + "name": "Energy produced since previous report" + }, + "max_reported": { + "name": "Lifetime maximum power" + }, + "last_report_duration": { + "name": "Last report duration" } }, "switch": { diff --git a/requirements_all.txt b/requirements_all.txt index da730bd041c877..f6de99444c8166 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -1962,7 +1962,7 @@ pyeiscp==0.0.7 pyemoncms==0.1.1 # homeassistant.components.enphase_envoy -pyenphase==2.0.1 +pyenphase==2.1.0 # homeassistant.components.envisalink pyenvisalink==4.7 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index f03fcba0cdc9f3..8cd601e2613521 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -1634,7 +1634,7 @@ pyeiscp==0.0.7 pyemoncms==0.1.1 # homeassistant.components.enphase_envoy -pyenphase==2.0.1 +pyenphase==2.1.0 # homeassistant.components.everlights pyeverlights==0.1.0 diff --git a/tests/components/enphase_envoy/fixtures/envoy.json b/tests/components/enphase_envoy/fixtures/envoy.json index c619d61a393933..85d8990b1abfd9 100644 --- a/tests/components/enphase_envoy/fixtures/envoy.json +++ b/tests/components/enphase_envoy/fixtures/envoy.json @@ -38,9 +38,19 @@ "inverters": { "1": { "serial_number": "1", - "last_report_date": 1, - "last_report_watts": 1, - "max_report_watts": 1 + "last_report_date": 1750460765, + "last_report_watts": 116, + "max_report_watts": 325, + "dc_voltage": 33.793, + "dc_current": 3.668, + "ac_voltage": 243.438, + "ac_current": 0.504, + "ac_frequency": 50.01, + "temperature": 23, + "energy_produced": 32.254, + "energy_today": 134, + "lifetime_energy": 130209, + "last_report_duration": 903 } }, "tariff": null, diff --git a/tests/components/enphase_envoy/fixtures/envoy_1p_metered.json b/tests/components/enphase_envoy/fixtures/envoy_1p_metered.json index 22aeca50ca0733..50f320edbc2897 100644 --- a/tests/components/enphase_envoy/fixtures/envoy_1p_metered.json +++ b/tests/components/enphase_envoy/fixtures/envoy_1p_metered.json @@ -78,7 +78,17 @@ "serial_number": "1", "last_report_date": 1, "last_report_watts": 1, - "max_report_watts": 1 + "max_report_watts": 1, + "dc_voltage": null, + "dc_current": null, + "ac_voltage": null, + "ac_current": null, + "ac_frequency": null, + "temperature": null, + "energy_produced": null, + "energy_today": null, + "lifetime_energy": null, + "last_report_duration": null } }, "tariff": { diff --git a/tests/components/enphase_envoy/fixtures/envoy_acb_batt.json b/tests/components/enphase_envoy/fixtures/envoy_acb_batt.json index 52e812f979e0f7..5cc35d4050c17d 100644 --- a/tests/components/enphase_envoy/fixtures/envoy_acb_batt.json +++ b/tests/components/enphase_envoy/fixtures/envoy_acb_batt.json @@ -220,7 +220,17 @@ "serial_number": "1", "last_report_date": 1, "last_report_watts": 1, - "max_report_watts": 1 + "max_report_watts": 1, + "dc_voltage": null, + "dc_current": null, + "ac_voltage": null, + "ac_current": null, + "ac_frequency": null, + "temperature": null, + "energy_produced": null, + "energy_today": null, + "lifetime_energy": null, + "last_report_duration": null } }, "tariff": { diff --git a/tests/components/enphase_envoy/fixtures/envoy_eu_batt.json b/tests/components/enphase_envoy/fixtures/envoy_eu_batt.json index 30fbc8d0f4f267..b9951a4c6fa1cf 100644 --- a/tests/components/enphase_envoy/fixtures/envoy_eu_batt.json +++ b/tests/components/enphase_envoy/fixtures/envoy_eu_batt.json @@ -208,7 +208,17 @@ "serial_number": "1", "last_report_date": 1, "last_report_watts": 1, - "max_report_watts": 1 + "max_report_watts": 1, + "dc_voltage": null, + "dc_current": null, + "ac_voltage": null, + "ac_current": null, + "ac_frequency": null, + "temperature": null, + "energy_produced": null, + "energy_today": null, + "lifetime_energy": null, + "last_report_duration": null } }, "tariff": { diff --git a/tests/components/enphase_envoy/fixtures/envoy_metered_batt_relay.json b/tests/components/enphase_envoy/fixtures/envoy_metered_batt_relay.json index 6cfbfed1e8eee9..73af5af0e5de95 100644 --- a/tests/components/enphase_envoy/fixtures/envoy_metered_batt_relay.json +++ b/tests/components/enphase_envoy/fixtures/envoy_metered_batt_relay.json @@ -412,7 +412,17 @@ "serial_number": "1", "last_report_date": 1, "last_report_watts": 1, - "max_report_watts": 1 + "max_report_watts": 1, + "dc_voltage": null, + "dc_current": null, + "ac_voltage": null, + "ac_current": null, + "ac_frequency": null, + "temperature": null, + "energy_produced": null, + "energy_today": null, + "lifetime_energy": null, + "last_report_duration": null } }, "tariff": { diff --git a/tests/components/enphase_envoy/fixtures/envoy_nobatt_metered_3p.json b/tests/components/enphase_envoy/fixtures/envoy_nobatt_metered_3p.json index 8c2767e33e5602..5a9ca140f8c5c4 100644 --- a/tests/components/enphase_envoy/fixtures/envoy_nobatt_metered_3p.json +++ b/tests/components/enphase_envoy/fixtures/envoy_nobatt_metered_3p.json @@ -227,7 +227,17 @@ "serial_number": "1", "last_report_date": 1, "last_report_watts": 1, - "max_report_watts": 1 + "max_report_watts": 1, + "dc_voltage": null, + "dc_current": null, + "ac_voltage": null, + "ac_current": null, + "ac_frequency": null, + "temperature": null, + "energy_produced": null, + "energy_today": null, + "lifetime_energy": null, + "last_report_duration": null } }, "tariff": { diff --git a/tests/components/enphase_envoy/fixtures/envoy_tot_cons_metered.json b/tests/components/enphase_envoy/fixtures/envoy_tot_cons_metered.json index 15cf2c173cb661..48b4de87867347 100644 --- a/tests/components/enphase_envoy/fixtures/envoy_tot_cons_metered.json +++ b/tests/components/enphase_envoy/fixtures/envoy_tot_cons_metered.json @@ -73,7 +73,17 @@ "serial_number": "1", "last_report_date": 1, "last_report_watts": 1, - "max_report_watts": 1 + "max_report_watts": 1, + "dc_voltage": null, + "dc_current": null, + "ac_voltage": null, + "ac_current": null, + "ac_frequency": null, + "temperature": null, + "energy_produced": null, + "energy_today": null, + "lifetime_energy": null, + "last_report_duration": null } }, "tariff": { diff --git a/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr b/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr index 7eb57488d66882..8eb6fcaac37cd2 100644 --- a/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr +++ b/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr @@ -359,7 +359,7 @@ 'unit_of_measurement': 'W', }), 'entity_id': 'sensor.inverter_1', - 'state': '1', + 'state': '116', }), }), dict({ @@ -367,7 +367,9 @@ 'aliases': list([ ]), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), 'categories': dict({ }), 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', @@ -376,7 +378,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -385,143 +387,19 @@ 'name': None, 'options': dict({ }), - 'original_device_class': 'timestamp', + 'original_device_class': 'voltage', 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', - 'unit_of_measurement': None, + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': 'V', }), 'state': None, }), - ]), - }), - ]), - 'envoy_model_data': dict({ - 'ctmeter_consumption': None, - 'ctmeter_consumption_phases': None, - 'ctmeter_production': None, - 'ctmeter_production_phases': None, - 'ctmeter_storage': None, - 'ctmeter_storage_phases': None, - 'dry_contact_settings': dict({ - }), - 'dry_contact_status': dict({ - }), - 'encharge_aggregate': None, - 'encharge_inventory': None, - 'encharge_power': None, - 'enpower': None, - 'inverters': dict({ - '1': dict({ - '__type': "", - 'repr': "EnvoyInverter(serial_number='1', last_report_date=1, last_report_watts=1, max_report_watts=1)", - }), - }), - 'system_consumption': None, - 'system_consumption_phases': None, - 'system_production': dict({ - '__type': "", - 'repr': 'EnvoySystemProduction(watt_hours_lifetime=1234, watt_hours_last_7_days=1234, watt_hours_today=1234, watts_now=1234)', - }), - 'system_production_phases': None, - 'tariff': None, - }), - 'envoy_properties': dict({ - 'active interface': dict({ - }), - 'active_phasecount': 0, - 'ct_consumption_meter': None, - 'ct_count': 0, - 'ct_production_meter': None, - 'ct_storage_meter': None, - 'envoy_firmware': '7.6.175', - 'envoy_model': 'Envoy', - 'part_number': '123456789', - 'phase_count': 1, - 'phase_mode': None, - 'supported_features': list([ - 'INVERTERS', - 'PRODUCTION', - ]), - }), - 'fixtures': dict({ - }), - 'raw_data': dict({ - 'varies_by': 'firmware_version', - }), - }) -# --- -# name: test_entry_diagnostics_with_fixtures - dict({ - 'config_entry': dict({ - 'data': dict({ - 'host': '1.1.1.1', - 'name': '**REDACTED**', - 'password': '**REDACTED**', - 'token': '**REDACTED**', - 'username': '**REDACTED**', - }), - 'disabled_by': None, - 'discovery_keys': dict({ - }), - 'domain': 'enphase_envoy', - 'entry_id': '45a36e55aaddb2007c5f6602e0c38e72', - 'minor_version': 1, - 'options': dict({ - 'diagnostics_include_fixtures': True, - }), - 'pref_disable_new_entities': False, - 'pref_disable_polling': False, - 'source': 'user', - 'subentries': list([ - ]), - 'title': '**REDACTED**', - 'unique_id': '**REDACTED**', - 'version': 1, - }), - 'envoy_entities_by_device': list([ - dict({ - 'device': dict({ - 'area_id': None, - 'config_entries': list([ - '45a36e55aaddb2007c5f6602e0c38e72', - ]), - 'config_entries_subentries': dict({ - '45a36e55aaddb2007c5f6602e0c38e72': list([ - None, - ]), - }), - 'configuration_url': None, - 'connections': list([ - ]), - 'disabled_by': None, - 'entry_type': None, - 'hw_version': '<>56789', - 'identifiers': list([ - list([ - 'enphase_envoy', - '<>', - ]), - ]), - 'is_new': False, - 'labels': list([ - ]), - 'manufacturer': 'Enphase', - 'model': 'Envoy', - 'model_id': None, - 'name': 'Envoy <>', - 'name_by_user': None, - 'primary_config_entry': '45a36e55aaddb2007c5f6602e0c38e72', - 'serial_number': '<>', - 'suggested_area': None, - 'sw_version': '7.6.175', - }), - 'entities': list([ dict({ 'entity': dict({ 'aliases': list([ @@ -535,10 +413,10 @@ 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', 'config_subentry_id': None, 'device_class': None, - 'disabled_by': None, + 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_<>_current_power_production', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -546,34 +424,19 @@ ]), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': 'kW', - }), }), - 'original_device_class': 'power', + 'original_device_class': 'current', 'original_icon': None, - 'original_name': 'Current power production', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production', - 'unique_id': '<>_production', - 'unit_of_measurement': 'kW', - }), - 'state': dict({ - 'attributes': dict({ - 'device_class': 'power', - 'friendly_name': 'Envoy <> Current power production', - 'state_class': 'measurement', - 'unit_of_measurement': 'kW', - }), - 'entity_id': 'sensor.envoy_<>_current_power_production', - 'state': '1.234', + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': 'A', }), + 'state': None, }), dict({ 'entity': dict({ @@ -581,17 +444,17 @@ ]), 'area_id': None, 'capabilities': dict({ - 'state_class': 'total_increasing', + 'state_class': 'measurement', }), 'categories': dict({ }), 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', 'config_subentry_id': None, 'device_class': None, - 'disabled_by': None, + 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_<>_energy_production_today', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -599,50 +462,37 @@ ]), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': 'kWh', - }), }), - 'original_device_class': 'energy', + 'original_device_class': 'voltage', 'original_icon': None, - 'original_name': 'Energy production today', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production', - 'unique_id': '<>_daily_production', - 'unit_of_measurement': 'kWh', - }), - 'state': dict({ - 'attributes': dict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy <> Energy production today', - 'state_class': 'total_increasing', - 'unit_of_measurement': 'kWh', - }), - 'entity_id': 'sensor.envoy_<>_energy_production_today', - 'state': '1.234', + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': 'V', }), + 'state': None, }), dict({ 'entity': dict({ 'aliases': list([ ]), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), 'categories': dict({ }), 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', 'config_subentry_id': None, 'device_class': None, - 'disabled_by': None, + 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_<>_energy_production_last_seven_days', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -650,33 +500,19 @@ ]), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': 'kWh', - }), }), - 'original_device_class': 'energy', + 'original_device_class': 'current', 'original_icon': None, - 'original_name': 'Energy production last seven days', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production', - 'unique_id': '<>_seven_days_production', - 'unit_of_measurement': 'kWh', - }), - 'state': dict({ - 'attributes': dict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy <> Energy production last seven days', - 'unit_of_measurement': 'kWh', - }), - 'entity_id': 'sensor.envoy_<>_energy_production_last_seven_days', - 'state': '1.234', + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': 'A', }), + 'state': None, }), dict({ 'entity': dict({ @@ -684,17 +520,17 @@ ]), 'area_id': None, 'capabilities': dict({ - 'state_class': 'total_increasing', + 'state_class': 'measurement', }), 'categories': dict({ }), 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', 'config_subentry_id': None, 'device_class': None, - 'disabled_by': None, + 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_<>_lifetime_energy_production', + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -702,74 +538,20 @@ ]), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': 'MWh', - }), }), - 'original_device_class': 'energy', + 'original_device_class': 'frequency', 'original_icon': None, - 'original_name': 'Lifetime energy production', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production', - 'unique_id': '<>_lifetime_production', - 'unit_of_measurement': 'MWh', - }), - 'state': dict({ - 'attributes': dict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy <> Lifetime energy production', - 'state_class': 'total_increasing', - 'unit_of_measurement': 'MWh', - }), - 'entity_id': 'sensor.envoy_<>_lifetime_energy_production', - 'state': '0.00<>', + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': 'Hz', }), + 'state': None, }), - ]), - }), - dict({ - 'device': dict({ - 'area_id': None, - 'config_entries': list([ - '45a36e55aaddb2007c5f6602e0c38e72', - ]), - 'config_entries_subentries': dict({ - '45a36e55aaddb2007c5f6602e0c38e72': list([ - None, - ]), - }), - 'configuration_url': None, - 'connections': list([ - ]), - 'disabled_by': None, - 'entry_type': None, - 'hw_version': None, - 'identifiers': list([ - list([ - 'enphase_envoy', - '1', - ]), - ]), - 'is_new': False, - 'labels': list([ - ]), - 'manufacturer': 'Enphase', - 'model': 'Inverter', - 'model_id': None, - 'name': 'Inverter 1', - 'name_by_user': None, - 'primary_config_entry': '45a36e55aaddb2007c5f6602e0c38e72', - 'serial_number': None, - 'suggested_area': None, - 'sw_version': None, - }), - 'entities': list([ dict({ 'entity': dict({ 'aliases': list([ @@ -783,10 +565,48 @@ 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', 'config_subentry_id': None, 'device_class': None, - 'disabled_by': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_temperature', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'temperature', + 'original_icon': None, + 'original_name': 'Temperature', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': '°C', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -794,31 +614,174 @@ ]), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 0, + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'kWh', }), }), - 'original_device_class': 'power', + 'original_device_class': 'energy', 'original_icon': None, - 'original_name': None, + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', - 'unit_of_measurement': 'W', + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': 'kWh', }), - 'state': dict({ - 'attributes': dict({ - 'device_class': 'power', - 'friendly_name': 'Inverter 1', + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced today', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': 'Wh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ 'state_class': 'measurement', - 'unit_of_measurement': 'W', }), - 'entity_id': 'sensor.inverter_1', - 'state': '1', + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_last_report_duration', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'duration', + 'original_icon': None, + 'original_name': 'Last report duration', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': 's', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced since previous report', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': 'mWh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'power', + 'original_icon': None, + 'original_name': 'Lifetime maximum power', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': 'W', }), + 'state': None, }), dict({ 'entity': dict({ @@ -877,7 +840,7 @@ 'inverters': dict({ '1': dict({ '__type': "", - 'repr': "EnvoyInverter(serial_number='1', last_report_date=1, last_report_watts=1, max_report_watts=1)", + 'repr': "EnvoyInverter(serial_number='1', last_report_date=1750460765, last_report_watts=116, max_report_watts=325, dc_voltage=33.793, dc_current=3.668, ac_voltage=243.438, ac_current=0.504, ac_frequency=50.01, temperature=23, lifetime_energy=130209, energy_produced=32.254, energy_today=134, last_report_duration=903)", }), }), 'system_consumption': None, @@ -908,55 +871,13 @@ ]), }), 'fixtures': dict({ - '/admin/lib/tariff': 'Testing request replies.', - '/admin/lib/tariff_log': '{"headers":{"Hello":"World"},"code":200}', - '/api/v1/production': 'Testing request replies.', - '/api/v1/production/inverters': 'Testing request replies.', - '/api/v1/production/inverters_log': '{"headers":{"Hello":"World"},"code":200}', - '/api/v1/production_log': '{"headers":{"Hello":"World"},"code":200}', - '/home': 'Testing request replies.', - '/home_log': '{"headers":{"Hello":"World"},"code":200}', - '/info': 'Testing request replies.', - '/info_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ensemble/dry_contacts': 'Testing request replies.', - '/ivp/ensemble/dry_contacts_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ensemble/generator': 'Testing request replies.', - '/ivp/ensemble/generator_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ensemble/inventory': 'Testing request replies.', - '/ivp/ensemble/inventory_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ensemble/power': 'Testing request replies.', - '/ivp/ensemble/power_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ensemble/secctrl': 'Testing request replies.', - '/ivp/ensemble/secctrl_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ensemble/status': 'Testing request replies.', - '/ivp/ensemble/status_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/meters': 'Testing request replies.', - '/ivp/meters/readings': 'Testing request replies.', - '/ivp/meters/readings_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/meters_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/sc/pvlimit': 'Testing request replies.', - '/ivp/sc/pvlimit_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ss/dry_contact_settings': 'Testing request replies.', - '/ivp/ss/dry_contact_settings_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ss/gen_config': 'Testing request replies.', - '/ivp/ss/gen_config_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ss/gen_schedule': 'Testing request replies.', - '/ivp/ss/gen_schedule_log': '{"headers":{"Hello":"World"},"code":200}', - '/ivp/ss/pel_settings': 'Testing request replies.', - '/ivp/ss/pel_settings_log': '{"headers":{"Hello":"World"},"code":200}', - '/production': 'Testing request replies.', - '/production.json': 'Testing request replies.', - '/production.json?details=1': 'Testing request replies.', - '/production.json?details=1_log': '{"headers":{"Hello":"World"},"code":200}', - '/production.json_log': '{"headers":{"Hello":"World"},"code":200}', - '/production_log': '{"headers":{"Hello":"World"},"code":200}', }), 'raw_data': dict({ 'varies_by': 'firmware_version', }), }) # --- -# name: test_entry_diagnostics_with_fixtures_with_error +# name: test_entry_diagnostics_with_fixtures dict({ 'config_entry': dict({ 'data': dict({ @@ -1317,7 +1238,7 @@ 'unit_of_measurement': 'W', }), 'entity_id': 'sensor.inverter_1', - 'state': '1', + 'state': '116', }), }), dict({ @@ -1325,7 +1246,9 @@ 'aliases': list([ ]), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), 'categories': dict({ }), 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', @@ -1334,7 +1257,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1343,205 +1266,19 @@ 'name': None, 'options': dict({ }), - 'original_device_class': 'timestamp', + 'original_device_class': 'voltage', 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', - 'unit_of_measurement': None, + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': 'V', }), 'state': None, }), - ]), - }), - ]), - 'envoy_model_data': dict({ - 'ctmeter_consumption': None, - 'ctmeter_consumption_phases': None, - 'ctmeter_production': None, - 'ctmeter_production_phases': None, - 'ctmeter_storage': None, - 'ctmeter_storage_phases': None, - 'dry_contact_settings': dict({ - }), - 'dry_contact_status': dict({ - }), - 'encharge_aggregate': None, - 'encharge_inventory': None, - 'encharge_power': None, - 'enpower': None, - 'inverters': dict({ - '1': dict({ - '__type': "", - 'repr': "EnvoyInverter(serial_number='1', last_report_date=1, last_report_watts=1, max_report_watts=1)", - }), - }), - 'system_consumption': None, - 'system_consumption_phases': None, - 'system_production': dict({ - '__type': "", - 'repr': 'EnvoySystemProduction(watt_hours_lifetime=1234, watt_hours_last_7_days=1234, watt_hours_today=1234, watts_now=1234)', - }), - 'system_production_phases': None, - 'tariff': None, - }), - 'envoy_properties': dict({ - 'active interface': dict({ - }), - 'active_phasecount': 0, - 'ct_consumption_meter': None, - 'ct_count': 0, - 'ct_production_meter': None, - 'ct_storage_meter': None, - 'envoy_firmware': '7.6.175', - 'envoy_model': 'Envoy', - 'part_number': '123456789', - 'phase_count': 1, - 'phase_mode': None, - 'supported_features': list([ - 'INVERTERS', - 'PRODUCTION', - ]), - }), - 'fixtures': dict({ - '/admin/lib/tariff_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/api/v1/production/inverters_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/api/v1/production_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/home_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/info_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ensemble/dry_contacts_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ensemble/generator_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ensemble/inventory_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ensemble/power_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ensemble/secctrl_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ensemble/status_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/meters/readings_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/meters_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/sc/pvlimit_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ss/dry_contact_settings_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ss/gen_config_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ss/gen_schedule_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/ivp/ss/pel_settings_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/production.json?details=1_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/production.json_log': dict({ - 'Error': "EnvoyError('Test')", - }), - '/production_log': dict({ - 'Error': "EnvoyError('Test')", - }), - }), - 'raw_data': dict({ - 'varies_by': 'firmware_version', - }), - }) -# --- -# name: test_entry_diagnostics_with_interface_information - dict({ - 'config_entry': dict({ - 'data': dict({ - 'host': '1.1.1.1', - 'name': '**REDACTED**', - 'password': '**REDACTED**', - 'token': '**REDACTED**', - 'username': '**REDACTED**', - }), - 'disabled_by': None, - 'discovery_keys': dict({ - }), - 'domain': 'enphase_envoy', - 'entry_id': '45a36e55aaddb2007c5f6602e0c38e72', - 'minor_version': 1, - 'options': dict({ - }), - 'pref_disable_new_entities': False, - 'pref_disable_polling': False, - 'source': 'user', - 'subentries': list([ - ]), - 'title': '**REDACTED**', - 'unique_id': '**REDACTED**', - 'version': 1, - }), - 'envoy_entities_by_device': list([ - dict({ - 'device': dict({ - 'area_id': None, - 'config_entries': list([ - '45a36e55aaddb2007c5f6602e0c38e72', - ]), - 'config_entries_subentries': dict({ - '45a36e55aaddb2007c5f6602e0c38e72': list([ - None, - ]), - }), - 'configuration_url': None, - 'connections': list([ - ]), - 'disabled_by': None, - 'entry_type': None, - 'hw_version': None, - 'identifiers': list([ - list([ - 'enphase_envoy', - '1', - ]), - ]), - 'is_new': False, - 'labels': list([ - ]), - 'manufacturer': 'Enphase', - 'model': 'Inverter', - 'model_id': None, - 'name': 'Inverter 1', - 'name_by_user': None, - 'primary_config_entry': '45a36e55aaddb2007c5f6602e0c38e72', - 'serial_number': None, - 'suggested_area': None, - 'sw_version': None, - }), - 'entities': list([ dict({ 'entity': dict({ 'aliases': list([ @@ -1555,10 +1292,10 @@ 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', 'config_subentry_id': None, 'device_class': None, - 'disabled_by': None, + 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1566,31 +1303,1983 @@ ]), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 0, - }), }), - 'original_device_class': 'power', + 'original_device_class': 'current', 'original_icon': None, - 'original_name': None, + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', - 'unit_of_measurement': 'W', + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': 'A', }), - 'state': dict({ - 'attributes': dict({ - 'device_class': 'power', - 'friendly_name': 'Inverter 1', + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ 'state_class': 'measurement', - 'unit_of_measurement': 'W', }), - 'entity_id': 'sensor.inverter_1', - 'state': '1', + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_ac_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'voltage', + 'original_icon': None, + 'original_name': 'AC voltage', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': 'V', }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_ac_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'current', + 'original_icon': None, + 'original_name': 'AC current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': 'A', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_frequency', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'frequency', + 'original_icon': None, + 'original_name': 'Frequency', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': 'Hz', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_temperature', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'temperature', + 'original_icon': None, + 'original_name': 'Temperature', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': '°C', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'kWh', + }), + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Lifetime energy produced', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': 'kWh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced today', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': 'Wh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_last_report_duration', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'duration', + 'original_icon': None, + 'original_name': 'Last report duration', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': 's', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced since previous report', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': 'mWh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'power', + 'original_icon': None, + 'original_name': 'Lifetime maximum power', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': 'W', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': None, + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_last_reported', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'timestamp', + 'original_icon': None, + 'original_name': 'Last reported', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', + 'unit_of_measurement': None, + }), + 'state': None, + }), + ]), + }), + ]), + 'envoy_model_data': dict({ + 'ctmeter_consumption': None, + 'ctmeter_consumption_phases': None, + 'ctmeter_production': None, + 'ctmeter_production_phases': None, + 'ctmeter_storage': None, + 'ctmeter_storage_phases': None, + 'dry_contact_settings': dict({ + }), + 'dry_contact_status': dict({ + }), + 'encharge_aggregate': None, + 'encharge_inventory': None, + 'encharge_power': None, + 'enpower': None, + 'inverters': dict({ + '1': dict({ + '__type': "", + 'repr': "EnvoyInverter(serial_number='1', last_report_date=1750460765, last_report_watts=116, max_report_watts=325, dc_voltage=33.793, dc_current=3.668, ac_voltage=243.438, ac_current=0.504, ac_frequency=50.01, temperature=23, lifetime_energy=130209, energy_produced=32.254, energy_today=134, last_report_duration=903)", + }), + }), + 'system_consumption': None, + 'system_consumption_phases': None, + 'system_production': dict({ + '__type': "", + 'repr': 'EnvoySystemProduction(watt_hours_lifetime=1234, watt_hours_last_7_days=1234, watt_hours_today=1234, watts_now=1234)', + }), + 'system_production_phases': None, + 'tariff': None, + }), + 'envoy_properties': dict({ + 'active interface': dict({ + }), + 'active_phasecount': 0, + 'ct_consumption_meter': None, + 'ct_count': 0, + 'ct_production_meter': None, + 'ct_storage_meter': None, + 'envoy_firmware': '7.6.175', + 'envoy_model': 'Envoy', + 'part_number': '123456789', + 'phase_count': 1, + 'phase_mode': None, + 'supported_features': list([ + 'INVERTERS', + 'PRODUCTION', + ]), + }), + 'fixtures': dict({ + '/admin/lib/tariff': 'Testing request replies.', + '/admin/lib/tariff_log': '{"headers":{"Hello":"World"},"code":200}', + '/api/v1/production': 'Testing request replies.', + '/api/v1/production/inverters': 'Testing request replies.', + '/api/v1/production/inverters_log': '{"headers":{"Hello":"World"},"code":200}', + '/api/v1/production_log': '{"headers":{"Hello":"World"},"code":200}', + '/home': 'Testing request replies.', + '/home_log': '{"headers":{"Hello":"World"},"code":200}', + '/info': 'Testing request replies.', + '/info_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ensemble/dry_contacts': 'Testing request replies.', + '/ivp/ensemble/dry_contacts_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ensemble/generator': 'Testing request replies.', + '/ivp/ensemble/generator_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ensemble/inventory': 'Testing request replies.', + '/ivp/ensemble/inventory_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ensemble/power': 'Testing request replies.', + '/ivp/ensemble/power_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ensemble/secctrl': 'Testing request replies.', + '/ivp/ensemble/secctrl_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ensemble/status': 'Testing request replies.', + '/ivp/ensemble/status_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/meters': 'Testing request replies.', + '/ivp/meters/readings': 'Testing request replies.', + '/ivp/meters/readings_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/meters_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/pdm/device_data': 'Testing request replies.', + '/ivp/pdm/device_data_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/sc/pvlimit': 'Testing request replies.', + '/ivp/sc/pvlimit_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ss/dry_contact_settings': 'Testing request replies.', + '/ivp/ss/dry_contact_settings_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ss/gen_config': 'Testing request replies.', + '/ivp/ss/gen_config_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ss/gen_schedule': 'Testing request replies.', + '/ivp/ss/gen_schedule_log': '{"headers":{"Hello":"World"},"code":200}', + '/ivp/ss/pel_settings': 'Testing request replies.', + '/ivp/ss/pel_settings_log': '{"headers":{"Hello":"World"},"code":200}', + '/production': 'Testing request replies.', + '/production.json': 'Testing request replies.', + '/production.json?details=1': 'Testing request replies.', + '/production.json?details=1_log': '{"headers":{"Hello":"World"},"code":200}', + '/production.json_log': '{"headers":{"Hello":"World"},"code":200}', + '/production_log': '{"headers":{"Hello":"World"},"code":200}', + }), + 'raw_data': dict({ + 'varies_by': 'firmware_version', + }), + }) +# --- +# name: test_entry_diagnostics_with_fixtures_with_error + dict({ + 'config_entry': dict({ + 'data': dict({ + 'host': '1.1.1.1', + 'name': '**REDACTED**', + 'password': '**REDACTED**', + 'token': '**REDACTED**', + 'username': '**REDACTED**', + }), + 'disabled_by': None, + 'discovery_keys': dict({ + }), + 'domain': 'enphase_envoy', + 'entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'minor_version': 1, + 'options': dict({ + 'diagnostics_include_fixtures': True, + }), + 'pref_disable_new_entities': False, + 'pref_disable_polling': False, + 'source': 'user', + 'subentries': list([ + ]), + 'title': '**REDACTED**', + 'unique_id': '**REDACTED**', + 'version': 1, + }), + 'envoy_entities_by_device': list([ + dict({ + 'device': dict({ + 'area_id': None, + 'config_entries': list([ + '45a36e55aaddb2007c5f6602e0c38e72', + ]), + 'config_entries_subentries': dict({ + '45a36e55aaddb2007c5f6602e0c38e72': list([ + None, + ]), + }), + 'configuration_url': None, + 'connections': list([ + ]), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': '<>56789', + 'identifiers': list([ + list([ + 'enphase_envoy', + '<>', + ]), + ]), + 'is_new': False, + 'labels': list([ + ]), + 'manufacturer': 'Enphase', + 'model': 'Envoy', + 'model_id': None, + 'name': 'Envoy <>', + 'name_by_user': None, + 'primary_config_entry': '45a36e55aaddb2007c5f6602e0c38e72', + 'serial_number': '<>', + 'suggested_area': None, + 'sw_version': '7.6.175', + }), + 'entities': list([ + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_<>_current_power_production', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'kW', + }), + }), + 'original_device_class': 'power', + 'original_icon': None, + 'original_name': 'Current power production', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'current_power_production', + 'unique_id': '<>_production', + 'unit_of_measurement': 'kW', + }), + 'state': dict({ + 'attributes': dict({ + 'device_class': 'power', + 'friendly_name': 'Envoy <> Current power production', + 'state_class': 'measurement', + 'unit_of_measurement': 'kW', + }), + 'entity_id': 'sensor.envoy_<>_current_power_production', + 'state': '1.234', + }), + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_<>_energy_production_today', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'kWh', + }), + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy production today', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'daily_production', + 'unique_id': '<>_daily_production', + 'unit_of_measurement': 'kWh', + }), + 'state': dict({ + 'attributes': dict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy <> Energy production today', + 'state_class': 'total_increasing', + 'unit_of_measurement': 'kWh', + }), + 'entity_id': 'sensor.envoy_<>_energy_production_today', + 'state': '1.234', + }), + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': None, + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_<>_energy_production_last_seven_days', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'kWh', + }), + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy production last seven days', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'seven_days_production', + 'unique_id': '<>_seven_days_production', + 'unit_of_measurement': 'kWh', + }), + 'state': dict({ + 'attributes': dict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy <> Energy production last seven days', + 'unit_of_measurement': 'kWh', + }), + 'entity_id': 'sensor.envoy_<>_energy_production_last_seven_days', + 'state': '1.234', + }), + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_<>_lifetime_energy_production', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'MWh', + }), + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Lifetime energy production', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_production', + 'unique_id': '<>_lifetime_production', + 'unit_of_measurement': 'MWh', + }), + 'state': dict({ + 'attributes': dict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy <> Lifetime energy production', + 'state_class': 'total_increasing', + 'unit_of_measurement': 'MWh', + }), + 'entity_id': 'sensor.envoy_<>_lifetime_energy_production', + 'state': '0.00<>', + }), + }), + ]), + }), + dict({ + 'device': dict({ + 'area_id': None, + 'config_entries': list([ + '45a36e55aaddb2007c5f6602e0c38e72', + ]), + 'config_entries_subentries': dict({ + '45a36e55aaddb2007c5f6602e0c38e72': list([ + None, + ]), + }), + 'configuration_url': None, + 'connections': list([ + ]), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': None, + 'identifiers': list([ + list([ + 'enphase_envoy', + '1', + ]), + ]), + 'is_new': False, + 'labels': list([ + ]), + 'manufacturer': 'Enphase', + 'model': 'Inverter', + 'model_id': None, + 'name': 'Inverter 1', + 'name_by_user': None, + 'primary_config_entry': '45a36e55aaddb2007c5f6602e0c38e72', + 'serial_number': None, + 'suggested_area': None, + 'sw_version': None, + }), + 'entities': list([ + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + }), + 'original_device_class': 'power', + 'original_icon': None, + 'original_name': None, + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': 'W', + }), + 'state': dict({ + 'attributes': dict({ + 'device_class': 'power', + 'friendly_name': 'Inverter 1', + 'state_class': 'measurement', + 'unit_of_measurement': 'W', + }), + 'entity_id': 'sensor.inverter_1', + 'state': '116', + }), + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_dc_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'voltage', + 'original_icon': None, + 'original_name': 'DC voltage', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': 'V', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_dc_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'current', + 'original_icon': None, + 'original_name': 'DC current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': 'A', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_ac_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'voltage', + 'original_icon': None, + 'original_name': 'AC voltage', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': 'V', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_ac_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'current', + 'original_icon': None, + 'original_name': 'AC current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': 'A', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_frequency', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'frequency', + 'original_icon': None, + 'original_name': 'Frequency', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': 'Hz', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_temperature', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'temperature', + 'original_icon': None, + 'original_name': 'Temperature', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': '°C', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'kWh', + }), + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Lifetime energy produced', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': 'kWh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced today', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': 'Wh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_last_report_duration', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'duration', + 'original_icon': None, + 'original_name': 'Last report duration', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': 's', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced since previous report', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': 'mWh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'power', + 'original_icon': None, + 'original_name': 'Lifetime maximum power', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': 'W', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': None, + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_last_reported', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'timestamp', + 'original_icon': None, + 'original_name': 'Last reported', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', + 'unit_of_measurement': None, + }), + 'state': None, + }), + ]), + }), + ]), + 'envoy_model_data': dict({ + 'ctmeter_consumption': None, + 'ctmeter_consumption_phases': None, + 'ctmeter_production': None, + 'ctmeter_production_phases': None, + 'ctmeter_storage': None, + 'ctmeter_storage_phases': None, + 'dry_contact_settings': dict({ + }), + 'dry_contact_status': dict({ + }), + 'encharge_aggregate': None, + 'encharge_inventory': None, + 'encharge_power': None, + 'enpower': None, + 'inverters': dict({ + '1': dict({ + '__type': "", + 'repr': "EnvoyInverter(serial_number='1', last_report_date=1750460765, last_report_watts=116, max_report_watts=325, dc_voltage=33.793, dc_current=3.668, ac_voltage=243.438, ac_current=0.504, ac_frequency=50.01, temperature=23, lifetime_energy=130209, energy_produced=32.254, energy_today=134, last_report_duration=903)", + }), + }), + 'system_consumption': None, + 'system_consumption_phases': None, + 'system_production': dict({ + '__type': "", + 'repr': 'EnvoySystemProduction(watt_hours_lifetime=1234, watt_hours_last_7_days=1234, watt_hours_today=1234, watts_now=1234)', + }), + 'system_production_phases': None, + 'tariff': None, + }), + 'envoy_properties': dict({ + 'active interface': dict({ + }), + 'active_phasecount': 0, + 'ct_consumption_meter': None, + 'ct_count': 0, + 'ct_production_meter': None, + 'ct_storage_meter': None, + 'envoy_firmware': '7.6.175', + 'envoy_model': 'Envoy', + 'part_number': '123456789', + 'phase_count': 1, + 'phase_mode': None, + 'supported_features': list([ + 'INVERTERS', + 'PRODUCTION', + ]), + }), + 'fixtures': dict({ + '/admin/lib/tariff_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/api/v1/production/inverters_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/api/v1/production_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/home_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/info_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ensemble/dry_contacts_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ensemble/generator_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ensemble/inventory_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ensemble/power_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ensemble/secctrl_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ensemble/status_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/meters/readings_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/meters_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/pdm/device_data_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/sc/pvlimit_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ss/dry_contact_settings_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ss/gen_config_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ss/gen_schedule_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/ivp/ss/pel_settings_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/production.json?details=1_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/production.json_log': dict({ + 'Error': "EnvoyError('Test')", + }), + '/production_log': dict({ + 'Error': "EnvoyError('Test')", + }), + }), + 'raw_data': dict({ + 'varies_by': 'firmware_version', + }), + }) +# --- +# name: test_entry_diagnostics_with_interface_information + dict({ + 'config_entry': dict({ + 'data': dict({ + 'host': '1.1.1.1', + 'name': '**REDACTED**', + 'password': '**REDACTED**', + 'token': '**REDACTED**', + 'username': '**REDACTED**', + }), + 'disabled_by': None, + 'discovery_keys': dict({ + }), + 'domain': 'enphase_envoy', + 'entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'minor_version': 1, + 'options': dict({ + }), + 'pref_disable_new_entities': False, + 'pref_disable_polling': False, + 'source': 'user', + 'subentries': list([ + ]), + 'title': '**REDACTED**', + 'unique_id': '**REDACTED**', + 'version': 1, + }), + 'envoy_entities_by_device': list([ + dict({ + 'device': dict({ + 'area_id': None, + 'config_entries': list([ + '45a36e55aaddb2007c5f6602e0c38e72', + ]), + 'config_entries_subentries': dict({ + '45a36e55aaddb2007c5f6602e0c38e72': list([ + None, + ]), + }), + 'configuration_url': None, + 'connections': list([ + ]), + 'disabled_by': None, + 'entry_type': None, + 'hw_version': None, + 'identifiers': list([ + list([ + 'enphase_envoy', + '1', + ]), + ]), + 'is_new': False, + 'labels': list([ + ]), + 'manufacturer': 'Enphase', + 'model': 'Inverter', + 'model_id': None, + 'name': 'Inverter 1', + 'name_by_user': None, + 'primary_config_entry': '45a36e55aaddb2007c5f6602e0c38e72', + 'serial_number': None, + 'suggested_area': None, + 'sw_version': None, + }), + 'entities': list([ + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + }), + 'original_device_class': 'power', + 'original_icon': None, + 'original_name': None, + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': 'W', + }), + 'state': dict({ + 'attributes': dict({ + 'device_class': 'power', + 'friendly_name': 'Inverter 1', + 'state_class': 'measurement', + 'unit_of_measurement': 'W', + }), + 'entity_id': 'sensor.inverter_1', + 'state': '116', + }), + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_dc_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'voltage', + 'original_icon': None, + 'original_name': 'DC voltage', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': 'V', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_dc_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'current', + 'original_icon': None, + 'original_name': 'DC current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': 'A', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_ac_voltage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'voltage', + 'original_icon': None, + 'original_name': 'AC voltage', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': 'V', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_ac_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'current', + 'original_icon': None, + 'original_name': 'AC current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': 'A', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_frequency', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'frequency', + 'original_icon': None, + 'original_name': 'Frequency', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': 'Hz', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_temperature', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'temperature', + 'original_icon': None, + 'original_name': 'Temperature', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': '°C', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + 'sensor.private': dict({ + 'suggested_unit_of_measurement': 'kWh', + }), + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Lifetime energy produced', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': 'kWh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total_increasing', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced today', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': 'Wh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_last_report_duration', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'duration', + 'original_icon': None, + 'original_name': 'Last report duration', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': 's', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'total', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'energy', + 'original_icon': None, + 'original_name': 'Energy produced since previous report', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': 'mWh', + }), + 'state': None, + }), + dict({ + 'entity': dict({ + 'aliases': list([ + ]), + 'area_id': None, + 'capabilities': dict({ + 'state_class': 'measurement', + }), + 'categories': dict({ + }), + 'config_entry_id': '45a36e55aaddb2007c5f6602e0c38e72', + 'config_subentry_id': None, + 'device_class': None, + 'disabled_by': 'integration', + 'domain': 'sensor', + 'entity_category': 'diagnostic', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'labels': list([ + ]), + 'name': None, + 'options': dict({ + }), + 'original_device_class': 'power', + 'original_icon': None, + 'original_name': 'Lifetime maximum power', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': 'W', + }), + 'state': None, }), dict({ 'entity': dict({ @@ -1901,7 +3590,7 @@ 'inverters': dict({ '1': dict({ '__type': "", - 'repr': "EnvoyInverter(serial_number='1', last_report_date=1, last_report_watts=1, max_report_watts=1)", + 'repr': "EnvoyInverter(serial_number='1', last_report_date=1750460765, last_report_watts=116, max_report_watts=325, dc_voltage=33.793, dc_current=3.668, ac_voltage=243.438, ac_current=0.504, ac_frequency=50.01, temperature=23, lifetime_energy=130209, energy_produced=32.254, energy_today=134, last_report_duration=903)", }), }), 'system_consumption': None, diff --git a/tests/components/enphase_envoy/snapshots/test_sensor.ambr b/tests/components/enphase_envoy/snapshots/test_sensor.ambr index d548b2a0f93721..51a596eda188f5 100644 --- a/tests/components/enphase_envoy/snapshots/test_sensor.ambr +++ b/tests/components/enphase_envoy/snapshots/test_sensor.ambr @@ -285,15 +285,17 @@ 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '116', }) # --- -# name: test_sensor[envoy][sensor.inverter_1_last_reported-entry] +# name: test_sensor[envoy][sensor.inverter_1_ac_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -301,7 +303,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -310,34 +312,39 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', - 'unit_of_measurement': None, + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy][sensor.inverter_1_last_reported-state] +# name: test_sensor[envoy][sensor.inverter_1_ac_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Inverter 1 Last reported', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 AC current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.inverter_1_ac_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1970-01-01T00:00:01+00:00', + 'state': '0.504', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_balanced_net_power_consumption-entry] +# name: test_sensor[envoy][sensor.inverter_1_ac_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -352,7 +359,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -364,39 +371,36 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption', - 'unique_id': '1234_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_balanced_net_power_consumption-state] +# name: test_sensor[envoy][sensor.inverter_1_ac_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 AC voltage', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.341', + 'state': '243.438', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_net_power_consumption-entry] +# name: test_sensor[envoy][sensor.inverter_1_dc_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -411,7 +415,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -423,39 +427,36 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption', - 'unique_id': '1234_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_net_power_consumption-state] +# name: test_sensor[envoy][sensor.inverter_1_dc_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 DC current', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.inverter_1_dc_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.101', + 'state': '3.668', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_consumption-entry] +# name: test_sensor[envoy][sensor.inverter_1_dc_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -470,7 +471,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -482,45 +483,42 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption', - 'unique_id': '1234_consumption', - 'unit_of_measurement': , + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_consumption-state] +# name: test_sensor[envoy][sensor.inverter_1_dc_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 DC voltage', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '33.793', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_production-entry] +# name: test_sensor[envoy][sensor.inverter_1_energy_produced_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -529,7 +527,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -541,44 +539,43 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production', + 'original_name': 'Energy produced since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production', - 'unique_id': '1234_production', - 'unit_of_measurement': , + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_production-state] +# name: test_sensor[envoy][sensor.inverter_1_energy_produced_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '32.254', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_last_seven_days-entry] +# name: test_sensor[envoy][sensor.inverter_1_energy_produced_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -586,7 +583,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -596,46 +593,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days', + 'original_name': 'Energy produced today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption', - 'unique_id': '1234_seven_days_consumption', - 'unit_of_measurement': , + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_last_seven_days-state] +# name: test_sensor[envoy][sensor.inverter_1_energy_produced_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days', - 'unit_of_measurement': , + 'friendly_name': 'Inverter 1 Energy produced today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '134', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_today-entry] +# name: test_sensor[envoy][sensor.inverter_1_frequency-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -644,7 +639,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -654,54 +649,53 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption', - 'unique_id': '1234_daily_consumption', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_today-state] +# name: test_sensor[envoy][sensor.inverter_1_frequency-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'frequency', + 'friendly_name': 'Inverter 1 Frequency', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.inverter_1_frequency', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '50.01', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_last_seven_days-entry] +# name: test_sensor[envoy][sensor.inverter_1_last_report_duration-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_last_report_duration', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -711,47 +705,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days', + 'original_name': 'Last report duration', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production', - 'unique_id': '1234_seven_days_production', - 'unit_of_measurement': , + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_last_seven_days-state] +# name: test_sensor[envoy][sensor.inverter_1_last_report_duration-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days', - 'unit_of_measurement': , + 'device_class': 'duration', + 'friendly_name': 'Inverter 1 Last report duration', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.inverter_1_last_report_duration', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '903', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_today-entry] +# name: test_sensor[envoy][sensor.inverter_1_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -759,7 +749,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.inverter_1_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -768,48 +758,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production', - 'unique_id': '1234_daily_production', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_today-state] +# name: test_sensor[envoy][sensor.inverter_1_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Inverter 1 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.inverter_1_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '2025-06-20T23:06:05+00:00', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_net_consumption_ct-entry] +# name: test_sensor[envoy][sensor.inverter_1_lifetime_energy_produced-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -818,7 +800,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -828,38 +810,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT', + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency', - 'unique_id': '1234_frequency', - 'unit_of_measurement': , + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_net_consumption_ct-state] +# name: test_sensor[envoy][sensor.inverter_1_lifetime_energy_produced-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '130.209', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_production_ct-entry] +# name: test_sensor[envoy][sensor.inverter_1_lifetime_maximum_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -873,8 +858,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -884,44 +869,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT', + 'original_name': 'Lifetime maximum power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency', - 'unique_id': '1234_production_ct_frequency', - 'unit_of_measurement': , + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_production_ct-state] +# name: test_sensor[envoy][sensor.inverter_1_lifetime_maximum_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT', + 'device_class': 'power', + 'friendly_name': 'Inverter 1 Lifetime maximum power', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '325', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] +# name: test_sensor[envoy][sensor.inverter_1_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -929,8 +914,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -942,45 +927,42 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption', - 'unique_id': '1234_lifetime_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] +# name: test_sensor[envoy][sensor.inverter_1_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'temperature', + 'friendly_name': 'Inverter 1 Temperature', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.inverter_1_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4.321', + 'state': '23', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_consumption-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_balanced_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -989,7 +971,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1002,44 +984,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption', + 'original_name': 'Balanced net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption', - 'unique_id': '1234_lifetime_consumption', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption', + 'unique_id': '1234_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_consumption-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_balanced_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '2.341', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_production-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1048,7 +1030,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1061,44 +1043,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production', + 'original_name': 'Current net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production', - 'unique_id': '1234_lifetime_production', - 'unit_of_measurement': , + 'translation_key': 'net_consumption', + 'unique_id': '1234_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_production-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '0.101', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_consumption-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1107,7 +1089,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1120,44 +1102,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption', + 'original_name': 'Current power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption', - 'unique_id': '1234_lifetime_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption', + 'unique_id': '1234_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_consumption-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021234', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_production-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1166,7 +1148,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1179,38 +1161,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production', + 'original_name': 'Current power production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production', - 'unique_id': '1234_lifetime_net_production', - 'unit_of_measurement': , + 'translation_key': 'current_power_production', + 'unique_id': '1234_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_production-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_current_power_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.022345', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -1222,8 +1204,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1232,46 +1214,56 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT', + 'original_name': 'Energy consumption last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags', - 'unique_id': '1234_net_consumption_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'seven_days_consumption', + 'unique_id': '1234_seven_days_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1280,52 +1272,55 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT', + 'original_name': 'Energy consumption today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags', - 'unique_id': '1234_production_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'daily_consumption', + 'unique_id': '1234_daily_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_consumption_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_net_consumption_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'options': list([ - , - , - , - ]), - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1334,49 +1329,47 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT', + 'original_name': 'Energy production last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status', - 'unique_id': '1234_net_consumption_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'seven_days_production', + 'unique_id': '1234_seven_days_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_net_consumption_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_production_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1384,8 +1377,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1394,39 +1387,42 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status', - 'unique_id': '1234_production_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'daily_production', + 'unique_id': '1234_daily_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_production_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_net_consumption_ct_current-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -1441,7 +1437,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1451,41 +1447,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current', + 'original_name': 'Frequency net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current', - 'unique_id': '1234_net_ct_current', - 'unit_of_measurement': , + 'translation_key': 'net_ct_frequency', + 'unique_id': '1234_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_net_consumption_ct_current-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_net_consumption_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -1500,7 +1493,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1510,43 +1503,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT', + 'original_name': 'Frequency production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor', - 'unique_id': '1234_net_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency', + 'unique_id': '1234_production_ct_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_net_consumption_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_frequency_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.21', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_production_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1555,7 +1549,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1565,43 +1559,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT', + 'original_name': 'Lifetime balanced net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor', - 'unique_id': '1234_production_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_balanced_net_consumption', + 'unique_id': '1234_lifetime_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_production_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.11', + 'state': '4.321', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_production_ct_current-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1610,7 +1608,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1623,44 +1621,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current', + 'original_name': 'Lifetime energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current', - 'unique_id': '1234_production_ct_current', - 'unit_of_measurement': , + 'translation_key': 'lifetime_consumption', + 'unique_id': '1234_lifetime_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_production_ct_current-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_net_consumption_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1669,7 +1667,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1679,47 +1677,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage', - 'unique_id': '1234_voltage', - 'unit_of_measurement': , + 'translation_key': 'lifetime_production', + 'unique_id': '1234_lifetime_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_net_consumption_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_production_ct-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1728,7 +1726,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1738,47 +1736,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT', + 'original_name': 'Lifetime net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage', - 'unique_id': '1234_production_ct_voltage', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption', + 'unique_id': '1234_lifetime_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_production_ct-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '0.021234', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -1787,7 +1785,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1797,38 +1795,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': None, + 'original_name': 'Lifetime net energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production', + 'unique_id': '1234_lifetime_net_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_lifetime_net_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Inverter 1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '0.022345', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_last_reported-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -1840,8 +1841,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1851,33 +1852,32 @@ 'name': None, 'options': dict({ }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Meter status flags active net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', + 'translation_key': 'net_ct_status_flags', + 'unique_id': '1234_net_consumption_ct_status_flags', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_last_reported-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Inverter 1 Last reported', + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', }), 'context': , - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1970-01-01T00:00:01+00:00', + 'state': '0', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -1889,8 +1889,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.acb_1234_battery', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1900,44 +1900,41 @@ 'name': None, 'options': dict({ }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Battery', + 'original_name': 'Meter status flags active production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1234_acb_soc', - 'unit_of_measurement': '%', + 'translation_key': 'production_ct_status_flags', + 'unique_id': '1234_production_ct_status_flags', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'ACB 1234 Battery', - 'unit_of_measurement': '%', + 'friendly_name': 'Envoy 1234 Meter status flags active production CT', }), 'context': , - 'entity_id': 'sensor.acb_1234_battery', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '25', + 'state': '2', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery_state-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ 'options': list([ - 'discharging', - 'idle', - 'charging', - 'full', + , + , + , ]), }), 'config_entry_id': , @@ -1946,8 +1943,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.acb_1234_battery_state', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1959,50 +1956,55 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery state', + 'original_name': 'Metering status net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'acb_battery_state', - 'unique_id': '1234_acb_battery_state', + 'translation_key': 'net_ct_metering_status', + 'unique_id': '1234_net_consumption_ct_metering_status', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery_state-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'enum', - 'friendly_name': 'ACB 1234 Battery state', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT', 'options': list([ - 'discharging', - 'idle', - 'charging', - 'full', + , + , + , ]), }), 'context': , - 'entity_id': 'sensor.acb_1234_battery_state', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'discharging', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.acb_1234_power-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.acb_1234_power', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2011,43 +2013,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 0, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power', + 'original_name': 'Metering status production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1234_acb_power', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status', + 'unique_id': '1234_production_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.acb_1234_power-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_metering_status_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'ACB 1234 Power', - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.acb_1234_power', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '260', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_apparent_power-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_net_consumption_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2055,7 +2060,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_apparent_power', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2065,42 +2070,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Apparent power', + 'original_name': 'Net consumption CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_apparent_power_mva', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current', + 'unique_id': '1234_net_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_apparent_power-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_net_consumption_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'apparent_power', - 'friendly_name': 'Encharge 123456 Apparent power', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_apparent_power', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.105', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_battery-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2108,7 +2119,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_battery', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2117,40 +2128,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery', + 'original_name': 'Power factor net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_soc', - 'unit_of_measurement': '%', + 'translation_key': 'net_ct_powerfactor', + 'unique_id': '1234_net_ct_powerfactor', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_battery-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Encharge 123456 Battery', - 'unit_of_measurement': '%', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_battery', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '54', + 'state': '0.21', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_last_reported-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2158,7 +2174,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_last_reported', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2167,39 +2183,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Power factor production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '123456_last_reported', + 'translation_key': 'production_ct_powerfactor', + 'unique_id': '1234_production_ct_powerfactor', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_last_reported-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_power_factor_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Encharge 123456 Last reported', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_last_reported', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2024-05-04T06:29:33+00:00', + 'state': '0.11', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_power-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_production_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2207,7 +2229,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_power', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2217,42 +2239,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power', + 'original_name': 'Production CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_real_power_mw', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current', + 'unique_id': '1234_production_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_power-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_production_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Encharge 123456 Power', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_power', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.105', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_temperature-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2260,7 +2288,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_temperature', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2272,40 +2300,46 @@ 'sensor': dict({ 'suggested_display_precision': 1, }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Temperature', + 'original_name': 'Voltage net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_temperature', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage', + 'unique_id': '1234_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_temperature-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'temperature', - 'friendly_name': 'Encharge 123456 Temperature', - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_temperature', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '16', + 'state': '112', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_available_battery_energy-entry] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2313,7 +2347,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_aggregated_available_battery_energy', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2323,42 +2357,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Aggregated available battery energy', + 'original_name': 'Voltage production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'aggregated_available_energy', - 'unique_id': '1234_aggregated_available_energy', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage', + 'unique_id': '1234_production_ct_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_available_battery_energy-state] +# name: test_sensor[envoy_1p_metered][sensor.envoy_1234_voltage_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy_storage', - 'friendly_name': 'Envoy 1234 Aggregated available battery energy', - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_aggregated_available_battery_energy', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2820', + 'state': '111', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_capacity-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2366,7 +2406,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_aggregated_battery_capacity', + 'entity_id': 'sensor.inverter_1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2379,39 +2419,42 @@ 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Aggregated Battery capacity', + 'original_name': None, 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'aggregated_max_capacity', - 'unique_id': '1234_aggregated_max_battery_capacity', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_capacity-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy_storage', - 'friendly_name': 'Envoy 1234 Aggregated Battery capacity', - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Inverter 1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_aggregated_battery_capacity', + 'entity_id': 'sensor.inverter_1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '7220', + 'state': '1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_soc-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_ac_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2419,7 +2462,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_aggregated_battery_soc', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2428,40 +2471,46 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Aggregated battery soc', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'aggregated_soc', - 'unique_id': '1234_aggregated_soc', - 'unit_of_measurement': '%', + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_soc-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_ac_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Aggregated battery soc', - 'unit_of_measurement': '%', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 AC current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_aggregated_battery_soc', + 'entity_id': 'sensor.inverter_1_ac_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '39', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_acb_battery_energy-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_ac_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2469,7 +2518,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_available_acb_battery_energy', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2479,42 +2528,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Available ACB battery energy', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'acb_available_energy', - 'unique_id': '1234_acb_available_energy', - 'unit_of_measurement': , + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_acb_battery_energy-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_ac_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy_storage', - 'friendly_name': 'Envoy 1234 Available ACB battery energy', - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 AC voltage', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_available_acb_battery_energy', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '930', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_battery_energy-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_dc_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2522,7 +2574,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_available_battery_energy', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2532,37 +2584,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Available battery energy', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'available_energy', - 'unique_id': '1234_available_energy', - 'unit_of_measurement': , + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_battery_energy-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_dc_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Available battery energy', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Inverter 1 DC current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_available_battery_energy', + 'entity_id': 'sensor.inverter_1_dc_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1890', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_balanced_net_power_consumption-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_dc_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -2577,7 +2630,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2589,44 +2642,43 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption', - 'unique_id': '1234_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_balanced_net_power_consumption-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_dc_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 DC voltage', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.341', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2634,7 +2686,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_battery', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2643,40 +2695,46 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery', + 'original_name': 'Energy produced since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1234_battery_level', - 'unit_of_measurement': '%', + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Battery', - 'unit_of_measurement': '%', + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_battery', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '54', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery_capacity-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2684,7 +2742,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_battery_capacity', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2699,32 +2757,33 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery capacity', + 'original_name': 'Energy produced today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'max_capacity', - 'unique_id': '1234_max_capacity', + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery_capacity-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Battery capacity', + 'friendly_name': 'Inverter 1 Energy produced today', + 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_battery_capacity', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3500', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_frequency-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -2739,7 +2798,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2751,39 +2810,36 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption', - 'unique_id': '1234_net_consumption', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_frequency-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption', + 'device_class': 'frequency', + 'friendly_name': 'Inverter 1 Frequency', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.inverter_1_frequency', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.101', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l1-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_last_report_duration-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -2797,8 +2853,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_last_report_duration', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2808,48 +2864,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l1', + 'original_name': 'Last report duration', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l1-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_last_report_duration-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l1', + 'device_class': 'duration', + 'friendly_name': 'Inverter 1 Last report duration', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_id': 'sensor.inverter_1_last_report_duration', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l2-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -2857,7 +2908,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.inverter_1_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2866,48 +2917,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l2', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l2-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Inverter 1 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.inverter_1_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.031', + 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l3-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_energy_produced-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -2916,7 +2959,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2926,41 +2969,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l3', + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l3-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_energy_produced-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.051', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_consumption-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_maximum_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -2974,8 +3017,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2985,41 +3028,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption', + 'original_name': 'Lifetime maximum power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption', - 'unique_id': '1234_consumption', - 'unit_of_measurement': , + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_consumption-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_maximum_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption', + 'friendly_name': 'Inverter 1 Lifetime maximum power', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_production-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -3033,8 +3073,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3046,39 +3086,36 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production', - 'unique_id': '1234_production', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_production-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production', + 'device_class': 'temperature', + 'friendly_name': 'Inverter 1 Temperature', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.inverter_1_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_last_seven_days-entry] +# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -3091,7 +3128,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.acb_1234_battery', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3100,47 +3137,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days', + 'original_name': 'Battery', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption', - 'unique_id': '1234_seven_days_consumption', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1234_acb_soc', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_last_seven_days-state] +# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days', - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'ACB 1234 Battery', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.acb_1234_battery', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '25', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_today-entry] +# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery_state-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + 'discharging', + 'idle', + 'charging', + 'full', + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -3149,7 +3185,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.acb_1234_battery_state', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3158,42 +3194,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today', + 'original_name': 'Battery state', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption', - 'unique_id': '1234_daily_consumption', - 'unit_of_measurement': , + 'translation_key': 'acb_battery_state', + 'unique_id': '1234_acb_battery_state', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_today-state] +# name: test_sensor[envoy_acb_batt][sensor.acb_1234_battery_state-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'ACB 1234 Battery state', + 'options': list([ + 'discharging', + 'idle', + 'charging', + 'full', + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.acb_1234_battery_state', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': 'discharging', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_last_seven_days-entry] +# name: test_sensor[envoy_acb_batt][sensor.acb_1234_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -3206,7 +3240,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.acb_1234_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3216,47 +3250,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days', + 'original_name': 'Power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production', - 'unique_id': '1234_seven_days_production', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1234_acb_power', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_last_seven_days-state] +# name: test_sensor[envoy_acb_batt][sensor.acb_1234_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days', - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'ACB 1234 Power', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.acb_1234_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '260', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_today-entry] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_apparent_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3264,7 +3293,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.encharge_123456_apparent_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3274,48 +3303,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today', + 'original_name': 'Apparent power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production', - 'unique_id': '1234_daily_production', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_apparent_power_mva', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_today-state] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_apparent_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'apparent_power', + 'friendly_name': 'Encharge 123456 Apparent power', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.encharge_123456_apparent_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '0.105', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_battery-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3323,7 +3346,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.encharge_123456_battery', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3332,46 +3355,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT', + 'original_name': 'Battery', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency', - 'unique_id': '1234_frequency', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_soc', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_battery-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Encharge 123456 Battery', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.encharge_123456_battery', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '54', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3379,7 +3396,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.encharge_123456_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3388,46 +3405,39 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l1', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l1', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '123456_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Encharge 123456 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.encharge_123456_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '2024-05-04T06:29:33+00:00', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3435,7 +3445,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.encharge_123456_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3445,45 +3455,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l2', + 'original_name': 'Power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_real_power_mw', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Encharge 123456 Power', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.encharge_123456_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '0.105', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3491,7 +3498,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.encharge_123456_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3504,42 +3511,39 @@ 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l3', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l3', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.encharge_123456_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'temperature', + 'friendly_name': 'Encharge 123456 Temperature', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.encharge_123456_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '16', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_available_battery_energy-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3547,7 +3551,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.envoy_1234_aggregated_available_battery_energy', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3557,45 +3561,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT', + 'original_name': 'Aggregated available battery energy', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency', - 'unique_id': '1234_production_ct_frequency', - 'unit_of_measurement': , + 'translation_key': 'aggregated_available_energy', + 'unique_id': '1234_aggregated_available_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_available_battery_energy-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy_storage', + 'friendly_name': 'Envoy 1234 Aggregated available battery energy', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.envoy_1234_aggregated_available_battery_energy', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '2820', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_capacity-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3603,7 +3604,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_aggregated_battery_capacity', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3613,45 +3614,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l1', + 'original_name': 'Aggregated Battery capacity', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l1', - 'unit_of_measurement': , + 'translation_key': 'aggregated_max_capacity', + 'unique_id': '1234_aggregated_max_battery_capacity', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_capacity-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy_storage', + 'friendly_name': 'Envoy 1234 Aggregated Battery capacity', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_aggregated_battery_capacity', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '7220', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_soc-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3659,7 +3657,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_aggregated_battery_soc', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3668,46 +3666,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l2', + 'original_name': 'Aggregated battery soc', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l2', - 'unit_of_measurement': , + 'translation_key': 'aggregated_soc', + 'unique_id': '1234_aggregated_soc', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_aggregated_battery_soc-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Envoy 1234 Aggregated battery soc', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_aggregated_battery_soc', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '39', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_acb_battery_energy-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3715,7 +3707,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_available_acb_battery_energy', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3725,45 +3717,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l3', + 'original_name': 'Available ACB battery energy', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'acb_available_energy', + 'unique_id': '1234_acb_available_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_acb_battery_energy-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy_storage', + 'friendly_name': 'Envoy 1234 Available ACB battery energy', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_available_acb_battery_energy', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '930', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_battery_energy-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3771,7 +3760,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_available_battery_energy', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3781,47 +3770,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption', + 'original_name': 'Available battery energy', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption', - 'unique_id': '1234_lifetime_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'available_energy', + 'unique_id': '1234_available_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_available_battery_energy-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Available battery energy', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_available_battery_energy', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4.321', + 'state': '1890', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_balanced_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -3830,7 +3815,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3843,45 +3828,43 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption', + 'original_name': 'Balanced net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption', - 'unique_id': '1234_lifetime_consumption', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption', + 'unique_id': '1234_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_balanced_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '2.341', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_production-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3889,7 +3872,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.envoy_1234_battery', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3898,49 +3881,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production', + 'original_name': 'Battery', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production', - 'unique_id': '1234_lifetime_production', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1234_battery_level', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_production-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Envoy 1234 Battery', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.envoy_1234_battery', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '54', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery_capacity-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -3948,7 +3922,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_battery_capacity', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3958,47 +3932,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption', + 'original_name': 'Battery capacity', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption', - 'unique_id': '1234_lifetime_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'max_capacity', + 'unique_id': '1234_max_capacity', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_battery_capacity-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Battery capacity', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_battery_capacity', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021234', + 'state': '3500', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4007,7 +3977,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4020,44 +3990,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l1', + 'original_name': 'Current net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'net_consumption', + 'unique_id': '1234_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212341', + 'state': '0.101', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4066,7 +4036,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4079,44 +4049,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l2', + 'original_name': 'Current net power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212342', + 'state': '0.021', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4125,7 +4095,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4138,44 +4108,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l3', + 'original_name': 'Current net power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212343', + 'state': '0.031', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4184,7 +4154,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4197,44 +4167,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production', + 'original_name': 'Current net power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production', - 'unique_id': '1234_lifetime_net_production', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_net_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.022345', + 'state': '0.051', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4243,7 +4213,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4256,44 +4226,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l1', + 'original_name': 'Current power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l1', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption', + 'unique_id': '1234_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223451', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4302,7 +4272,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4315,45 +4285,43 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l2', + 'original_name': 'Current power production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l2', - 'unit_of_measurement': , + 'translation_key': 'current_power_production', + 'unique_id': '1234_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_current_power_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223452', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -4361,7 +4329,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4371,54 +4339,55 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l3', + 'original_name': 'Energy consumption last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l3', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption', + 'unique_id': '1234_seven_days_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy consumption last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223453', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4427,33 +4396,42 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT', + 'original_name': 'Energy consumption today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags', - 'unique_id': '1234_net_consumption_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'daily_consumption', + 'unique_id': '1234_daily_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_consumption_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -4465,8 +4443,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4475,46 +4453,56 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l1', + 'original_name': 'Energy production last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l1', - 'unit_of_measurement': None, + 'translation_key': 'seven_days_production', + 'unique_id': '1234_seven_days_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4523,46 +4511,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l2', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l2', - 'unit_of_measurement': None, - }) -# --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] + 'translation_key': 'daily_production', + 'unique_id': '1234_daily_production', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4571,46 +4570,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l3', + 'original_name': 'Frequency net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency', + 'unique_id': '1234_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4619,46 +4626,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT', + 'original_name': 'Frequency net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags', - 'unique_id': '1234_production_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4667,46 +4682,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l1', + 'original_name': 'Frequency net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l1', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4715,46 +4738,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l2', + 'original_name': 'Frequency net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l2', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4763,43 +4794,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l3', + 'original_name': 'Frequency production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency', + 'unique_id': '1234_production_ct_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4807,8 +4840,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4817,49 +4850,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT', + 'original_name': 'Frequency production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status', - 'unique_id': '1234_net_consumption_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4867,8 +4896,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4877,49 +4906,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l1', + 'original_name': 'Frequency production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4927,8 +4952,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4937,49 +4962,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l2', + 'original_name': 'Frequency production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_frequency_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -4987,8 +5008,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -4997,49 +5018,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l3', + 'original_name': 'Lifetime balanced net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_balanced_net_consumption', + 'unique_id': '1234_lifetime_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '4.321', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5047,8 +5067,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5057,49 +5077,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT', + 'original_name': 'Lifetime energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status', - 'unique_id': '1234_production_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_consumption', + 'unique_id': '1234_lifetime_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5107,8 +5126,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5117,49 +5136,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l1', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_production', + 'unique_id': '1234_lifetime_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5167,8 +5185,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5177,49 +5195,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l2', + 'original_name': 'Lifetime net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_net_consumption', + 'unique_id': '1234_lifetime_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '0.021234', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5227,8 +5244,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5237,45 +5254,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l3', + 'original_name': 'Lifetime net energy consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '0.212341', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5284,7 +5304,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5297,44 +5317,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current', + 'original_name': 'Lifetime net energy consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current', - 'unique_id': '1234_net_ct_current', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '0.212342', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5343,7 +5363,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5356,44 +5376,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l1', + 'original_name': 'Lifetime net energy consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '0.212343', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5402,7 +5422,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5415,44 +5435,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l2', + 'original_name': 'Lifetime net energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production', + 'unique_id': '1234_lifetime_net_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '0.022345', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5461,7 +5481,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5474,44 +5494,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l3', + 'original_name': 'Lifetime net energy production l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l3', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '0.223451', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5520,7 +5540,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5530,43 +5550,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT', + 'original_name': 'Lifetime net energy production l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor', - 'unique_id': '1234_net_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.21', + 'state': '0.223452', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -5575,7 +5599,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5585,52 +5609,54 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l1', + 'original_name': 'Lifetime net energy production l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.22', + 'state': '0.223453', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5639,53 +5665,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Power factor net consumption CT l2', + 'original_name': 'Meter status flags active net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l2', + 'translation_key': 'net_ct_status_flags', + 'unique_id': '1234_net_consumption_ct_status_flags', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', - 'state_class': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.23', + 'state': '0', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5694,53 +5713,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Power factor net consumption CT l3', + 'original_name': 'Meter status flags active net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l3', + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l1', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', - 'state_class': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.24', + 'state': '0', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5749,53 +5761,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Power factor production CT', + 'original_name': 'Meter status flags active net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor', - 'unique_id': '1234_production_ct_powerfactor', + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l2', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT', - 'state_class': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.11', + 'state': '0', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5804,53 +5809,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Power factor production CT l1', + 'original_name': 'Meter status flags active net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l1', + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l3', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l1', - 'state_class': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.12', + 'state': '0', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5859,53 +5857,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Power factor production CT l2', + 'original_name': 'Meter status flags active production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l2', + 'translation_key': 'production_ct_status_flags', + 'unique_id': '1234_production_ct_status_flags', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l2', - 'state_class': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.13', + 'state': '2', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5914,53 +5905,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Power factor production CT l3', + 'original_name': 'Meter status flags active production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l3', + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l1', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l3', - 'state_class': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.14', + 'state': '1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -5969,57 +5953,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Production CT current', + 'original_name': 'Meter status flags active production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current', - 'unique_id': '1234_production_ct_current', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '1', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6028,48 +6001,43 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Production CT current l1', + 'original_name': 'Meter status flags active production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l1', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '0', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -6077,8 +6045,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6087,48 +6055,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l2', + 'original_name': 'Metering status net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status', + 'unique_id': '1234_net_consumption_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -6136,8 +6105,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6146,55 +6115,58 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l3', + 'original_name': 'Metering status net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_energy-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6203,51 +6175,58 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 0, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Reserve battery energy', + 'original_name': 'Metering status net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'reserve_energy', - 'unique_id': '1234_reserve_energy', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_energy-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Reserve battery energy', - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_level-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6257,40 +6236,48 @@ 'name': None, 'options': dict({ }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Reserve battery level', + 'original_name': 'Metering status net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'reserve_soc', - 'unique_id': '1234_reserve_soc', - 'unit_of_measurement': '%', + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_level-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Reserve battery level', - 'unit_of_measurement': '%', + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -6298,8 +6285,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6308,48 +6295,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT', + 'original_name': 'Metering status production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage', - 'unique_id': '1234_voltage', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status', + 'unique_id': '1234_production_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -6357,8 +6345,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6367,48 +6355,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l1', + 'original_name': 'Metering status production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l1', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -6416,8 +6405,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6426,48 +6415,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l2', + 'original_name': 'Metering status production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l2', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -6475,8 +6465,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6485,42 +6475,39 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l3', + 'original_name': 'Metering status production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_metering_status_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l3', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -6535,7 +6522,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6545,41 +6532,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT', + 'original_name': 'Net consumption CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage', - 'unique_id': '1234_production_ct_voltage', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current', + 'unique_id': '1234_net_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -6594,7 +6581,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6604,41 +6591,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l1', + 'original_name': 'Net consumption CT current l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l1', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -6653,7 +6640,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6663,41 +6650,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l2', + 'original_name': 'Net consumption CT current l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l2', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -6712,7 +6699,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6722,41 +6709,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l3', + 'original_name': 'Net consumption CT current l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_net_consumption_ct_current_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l3', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -6771,7 +6758,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6781,43 +6768,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': None, + 'original_name': 'Power factor net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_powerfactor', + 'unique_id': '1234_net_ct_powerfactor', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Inverter 1', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '0.21', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_last_reported-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -6825,7 +6813,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6834,39 +6822,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Power factor net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l1', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_last_reported-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Inverter 1 Last reported', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1970-01-01T00:00:01+00:00', + 'state': '0.22', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_apparent_power-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -6874,7 +6868,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_apparent_power', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6884,42 +6878,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Apparent power', + 'original_name': 'Power factor net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_apparent_power_mva', - 'unit_of_measurement': , + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_apparent_power-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'apparent_power', - 'friendly_name': 'Encharge 123456 Apparent power', - 'unit_of_measurement': , + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_apparent_power', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.0', + 'state': '0.23', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_battery-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -6927,7 +6923,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_battery', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6936,40 +6932,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery', + 'original_name': 'Power factor net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_soc', - 'unit_of_measurement': '%', + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_battery-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Encharge 123456 Battery', - 'unit_of_measurement': '%', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_battery', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4', + 'state': '0.24', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_last_reported-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -6977,7 +6978,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_last_reported', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -6986,39 +6987,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Power factor production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '123456_last_reported', + 'translation_key': 'production_ct_powerfactor', + 'unique_id': '1234_production_ct_powerfactor', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_last_reported-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Encharge 123456 Last reported', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_last_reported', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2024-05-04T06:29:33+00:00', + 'state': '0.11', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_power-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7026,7 +7033,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_power', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7036,42 +7043,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power', + 'original_name': 'Power factor production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_real_power_mw', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_power-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Encharge 123456 Power', - 'unit_of_measurement': , + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l1', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_power', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.0', + 'state': '0.12', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_temperature-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7079,7 +7088,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_temperature', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7089,42 +7098,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Temperature', + 'original_name': 'Power factor production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_temperature', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_temperature-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'temperature', - 'friendly_name': 'Encharge 123456 Temperature', - 'unit_of_measurement': , + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l2', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.encharge_123456_temperature', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '16', + 'state': '0.13', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_available_battery_energy-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7132,7 +7143,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_available_battery_energy', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7142,37 +7153,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Available battery energy', + 'original_name': 'Power factor production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'available_energy', - 'unique_id': '1234_available_energy', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_available_battery_energy-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_power_factor_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Available battery energy', - 'unit_of_measurement': , + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l3', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_available_battery_energy', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '140', + 'state': '0.14', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_balanced_net_power_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -7187,7 +7198,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7200,43 +7211,45 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption', + 'original_name': 'Production CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption', - 'unique_id': '1234_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current', + 'unique_id': '1234_production_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_balanced_net_power_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.341', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7244,7 +7257,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_battery', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7253,40 +7266,49 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery', + 'original_name': 'Production CT current l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1234_battery_level', - 'unit_of_measurement': '%', + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Battery', - 'unit_of_measurement': '%', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_battery', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery_capacity-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7294,7 +7316,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_battery_capacity', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7304,37 +7326,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery capacity', + 'original_name': 'Production CT current l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'max_capacity', - 'unique_id': '1234_max_capacity', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery_capacity-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Battery capacity', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_battery_capacity', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3500', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -7349,7 +7375,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7362,45 +7388,43 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption', + 'original_name': 'Production CT current l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption', - 'unique_id': '1234_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_production_ct_current_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.101', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_energy-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7408,7 +7432,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7418,48 +7442,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l1', + 'original_name': 'Reserve battery energy', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'reserve_energy', + 'unique_id': '1234_reserve_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_energy-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Reserve battery energy', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021', + 'state': '0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_level-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7467,7 +7485,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_reserve_battery_level', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7476,42 +7494,35 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l2', + 'original_name': 'Reserve battery level', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'reserve_soc', + 'unique_id': '1234_reserve_soc', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_reserve_battery_level-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Envoy 1234 Reserve battery level', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_reserve_battery_level', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.031', + 'state': '0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -7526,7 +7537,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7536,41 +7547,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l3', + 'original_name': 'Voltage net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage', + 'unique_id': '1234_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l3', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.051', + 'state': '112', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -7585,7 +7596,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7595,41 +7606,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption', + 'original_name': 'Voltage net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption', - 'unique_id': '1234_consumption', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '112', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_production-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -7644,7 +7655,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7654,46 +7665,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production', + 'original_name': 'Voltage net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production', - 'unique_id': '1234_production', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_production-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '112', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_last_seven_days-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7701,7 +7714,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7714,43 +7727,44 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days', + 'original_name': 'Voltage net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption', - 'unique_id': '1234_seven_days_consumption', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_last_seven_days-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days', - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '112', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_today-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -7759,7 +7773,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7769,46 +7783,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today', + 'original_name': 'Voltage production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption', - 'unique_id': '1234_daily_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage', + 'unique_id': '1234_production_ct_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_today-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '111', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_last_seven_days-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -7816,7 +7832,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7829,43 +7845,44 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days', + 'original_name': 'Voltage production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production', - 'unique_id': '1234_seven_days_production', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_last_seven_days-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days', - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '111', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_today-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -7874,7 +7891,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7884,41 +7901,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today', + 'original_name': 'Voltage production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production', - 'unique_id': '1234_daily_production', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_today-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '111', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -7933,7 +7950,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7945,36 +7962,39 @@ 'sensor': dict({ 'suggested_display_precision': 1, }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT', + 'original_name': 'Voltage production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency', - 'unique_id': '1234_frequency', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.envoy_1234_voltage_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '111', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -7989,7 +8009,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.inverter_1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -7999,38 +8019,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l1', + 'original_name': None, 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l1', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', + 'device_class': 'power', + 'friendly_name': 'Inverter 1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.inverter_1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_ac_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8045,7 +8065,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8055,38 +8075,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l2', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l2', - 'unit_of_measurement': , + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_ac_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 AC current', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.inverter_1_ac_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_ac_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8101,7 +8121,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8111,38 +8131,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l3', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_ac_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 AC voltage', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_dc_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8157,7 +8177,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8167,38 +8187,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency', - 'unique_id': '1234_production_ct_frequency', - 'unit_of_measurement': , + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_dc_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 DC current', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.inverter_1_dc_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_dc_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8213,7 +8233,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8223,44 +8243,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l1', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l1', - 'unit_of_measurement': , + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_dc_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l1', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 DC voltage', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -8269,7 +8289,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8279,44 +8299,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l2', + 'original_name': 'Energy produced since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l2', - 'unit_of_measurement': , + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l3-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -8325,7 +8345,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8335,44 +8355,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l3', + 'original_name': 'Energy produced today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l3-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_frequency-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -8381,7 +8401,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8393,45 +8413,42 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption', - 'unique_id': '1234_lifetime_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_frequency-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'frequency', + 'friendly_name': 'Inverter 1 Frequency', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.inverter_1_frequency', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4.321', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_last_report_duration-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -8439,8 +8456,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_last_report_duration', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8450,48 +8467,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption', + 'original_name': 'Last report duration', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption', - 'unique_id': '1234_lifetime_consumption', - 'unit_of_measurement': , + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_last_report_duration-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'duration', + 'friendly_name': 'Inverter 1 Last report duration', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.inverter_1_last_report_duration', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_production-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -8499,7 +8511,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.inverter_1_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8508,42 +8520,34 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production', - 'unique_id': '1234_lifetime_production', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_production-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Inverter 1 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.inverter_1_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_energy_produced-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8558,7 +8562,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8568,47 +8572,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption', + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption', - 'unique_id': '1234_lifetime_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_energy_produced-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', + 'friendly_name': 'Inverter 1 Lifetime energy produced', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_maximum_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -8616,8 +8620,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8627,47 +8631,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l1', + 'original_name': 'Lifetime maximum power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_maximum_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Inverter 1 Lifetime maximum power', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212341', + 'state': '1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -8675,8 +8676,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8688,46 +8689,41 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l2', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'temperature', + 'friendly_name': 'Inverter 1 Temperature', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_id': 'sensor.inverter_1_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212342', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_apparent_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -8735,7 +8731,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.encharge_123456_apparent_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8745,48 +8741,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l3', + 'original_name': 'Apparent power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_apparent_power_mva', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_apparent_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'apparent_power', + 'friendly_name': 'Encharge 123456 Apparent power', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.encharge_123456_apparent_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212343', + 'state': '0.0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production-entry] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_battery-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -8794,7 +8784,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.encharge_123456_battery', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8803,49 +8793,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production', + 'original_name': 'Battery', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production', - 'unique_id': '1234_lifetime_net_production', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_soc', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production-state] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_battery-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Encharge 123456 Battery', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.encharge_123456_battery', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.022345', + 'state': '4', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -8853,7 +8834,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.encharge_123456_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8862,49 +8843,39 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l1', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l1', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '123456_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Encharge 123456 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.encharge_123456_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223451', + 'state': '2024-05-04T06:29:33+00:00', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -8912,7 +8883,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.encharge_123456_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8922,48 +8893,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l2', + 'original_name': 'Power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_real_power_mw', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Encharge 123456 Power', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.encharge_123456_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223452', + 'state': '0.0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -8971,7 +8936,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.encharge_123456_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8981,41 +8946,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l3', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l3', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.encharge_123456_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'temperature', + 'friendly_name': 'Encharge 123456 Temperature', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.encharge_123456_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223453', + 'state': '16', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_available_battery_energy-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -9027,8 +8988,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_available_battery_energy', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9037,46 +8998,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT', + 'original_name': 'Available battery energy', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags', - 'unique_id': '1234_net_consumption_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'available_energy', + 'unique_id': '1234_available_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_available_battery_energy-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Available battery energy', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_available_battery_energy', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '140', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_balanced_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9085,33 +9053,42 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l1', + 'original_name': 'Balanced net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l1', - 'unit_of_measurement': None, + 'translation_key': 'balanced_net_consumption', + 'unique_id': '1234_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_balanced_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '2.341', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -9123,8 +9100,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_battery', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9134,32 +9111,34 @@ 'name': None, 'options': dict({ }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l2', + 'original_name': 'Battery', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l2', - 'unit_of_measurement': None, + 'translation_key': None, + 'unique_id': '1234_battery_level', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', + 'device_class': 'battery', + 'friendly_name': 'Envoy 1234 Battery', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_battery', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '4', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery_capacity-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -9171,8 +9150,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_battery_capacity', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9181,46 +9160,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l3', + 'original_name': 'Battery capacity', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'max_capacity', + 'unique_id': '1234_max_capacity', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_battery_capacity-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Battery capacity', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_battery_capacity', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '3500', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9229,46 +9215,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT', + 'original_name': 'Current net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags', - 'unique_id': '1234_production_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'net_consumption', + 'unique_id': '1234_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2', + 'state': '0.101', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9277,46 +9274,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l1', + 'original_name': 'Current net power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l1', - 'unit_of_measurement': None, + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '0.021', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9325,46 +9333,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l2', + 'original_name': 'Current net power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l2', - 'unit_of_measurement': None, + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '0.031', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9373,43 +9392,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l3', + 'original_name': 'Current net power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_net_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '0.051', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -9417,8 +9441,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9427,49 +9451,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT', + 'original_name': 'Current power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status', - 'unique_id': '1234_net_consumption_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'current_power_consumption', + 'unique_id': '1234_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -9477,8 +9500,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_current_power_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9487,58 +9510,55 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l1', + 'original_name': 'Current power production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'current_power_production', + 'unique_id': '1234_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_current_power_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'options': list([ - , - , - , - ]), - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9547,49 +9567,47 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l2', + 'original_name': 'Energy consumption last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'seven_days_consumption', + 'unique_id': '1234_seven_days_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -9597,8 +9615,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9607,58 +9625,55 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l3', + 'original_name': 'Energy consumption today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'daily_consumption', + 'unique_id': '1234_daily_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_consumption_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'options': list([ - , - , - , - ]), - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9667,49 +9682,47 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT', + 'original_name': 'Energy production last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status', - 'unique_id': '1234_production_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'seven_days_production', + 'unique_id': '1234_seven_days_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -9717,8 +9730,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9727,49 +9740,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l1', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'daily_production', + 'unique_id': '1234_daily_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -9777,8 +9789,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9787,49 +9799,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l2', + 'original_name': 'Frequency net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency', + 'unique_id': '1234_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -9837,8 +9845,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9847,39 +9855,39 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l3', + 'original_name': 'Frequency net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -9894,7 +9902,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9904,41 +9912,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current', + 'original_name': 'Frequency net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current', - 'unique_id': '1234_net_ct_current', - 'unit_of_measurement': , + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -9953,7 +9958,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -9963,41 +9968,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l1', + 'original_name': 'Frequency net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l1', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -10012,7 +10014,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10022,41 +10024,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l2', + 'original_name': 'Frequency production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_frequency', + 'unique_id': '1234_production_ct_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l2', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -10071,7 +10070,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10081,41 +10080,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l3', + 'original_name': 'Frequency production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -10130,7 +10126,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10140,37 +10136,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT', + 'original_name': 'Frequency production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor', - 'unique_id': '1234_net_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l2', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.21', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -10185,7 +10182,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10195,43 +10192,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l1', + 'original_name': 'Frequency production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_frequency_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l3', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.22', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10240,7 +10238,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10250,43 +10248,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l2', + 'original_name': 'Lifetime balanced net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l2', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_balanced_net_consumption', + 'unique_id': '1234_lifetime_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.23', + 'state': '4.321', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10295,7 +10297,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10305,43 +10307,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l3', + 'original_name': 'Lifetime energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l3', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_consumption', + 'unique_id': '1234_lifetime_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.24', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10350,7 +10356,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10360,43 +10366,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor', - 'unique_id': '1234_production_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_production', + 'unique_id': '1234_lifetime_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.11', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10405,7 +10415,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10415,43 +10425,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l1', + 'original_name': 'Lifetime net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_net_consumption', + 'unique_id': '1234_lifetime_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l1', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.12', + 'state': '0.021234', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10460,7 +10474,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10470,43 +10484,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l2', + 'original_name': 'Lifetime net energy consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l2', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l2', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.13', + 'state': '0.212341', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10515,7 +10533,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10525,43 +10543,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l3', + 'original_name': 'Lifetime net energy consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l3', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l3', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.14', + 'state': '0.212342', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10570,7 +10592,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10583,44 +10605,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current', + 'original_name': 'Lifetime net energy consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current', - 'unique_id': '1234_production_ct_current', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '0.212343', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10629,7 +10651,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10642,44 +10664,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l1', + 'original_name': 'Lifetime net energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production', + 'unique_id': '1234_lifetime_net_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '0.022345', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10688,7 +10710,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10701,44 +10723,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l2', + 'original_name': 'Lifetime net energy production l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '0.223451', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -10747,7 +10769,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10760,43 +10782,45 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l3', + 'original_name': 'Lifetime net energy production l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l3', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '0.223452', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_energy-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -10804,7 +10828,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10814,37 +10838,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Reserve battery energy', + 'original_name': 'Lifetime net energy production l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'reserve_energy', - 'unique_id': '1234_reserve_energy', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_energy-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_lifetime_net_energy_production_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Reserve battery energy', - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '0.223453', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_level-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -10856,8 +10884,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10867,49 +10895,45 @@ 'name': None, 'options': dict({ }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Reserve battery level', + 'original_name': 'Meter status flags active net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'reserve_soc', - 'unique_id': '1234_reserve_soc', - 'unit_of_measurement': '%', + 'translation_key': 'net_ct_status_flags', + 'unique_id': '1234_net_consumption_ct_status_flags', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_level-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Reserve battery level', - 'unit_of_measurement': '%', + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', }), 'context': , - 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , 'state': '0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10918,57 +10942,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage net consumption CT', + 'original_name': 'Meter status flags active net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage', - 'unique_id': '1234_voltage', - 'unit_of_measurement': , + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -10977,57 +10990,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage net consumption CT l1', + 'original_name': 'Meter status flags active net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11036,57 +11038,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage net consumption CT l2', + 'original_name': 'Meter status flags active net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11095,57 +11086,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage net consumption CT l3', + 'original_name': 'Meter status flags active production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags', + 'unique_id': '1234_production_ct_status_flags', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '2', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11154,57 +11134,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage production CT', + 'original_name': 'Meter status flags active production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage', - 'unique_id': '1234_production_ct_voltage', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11213,57 +11182,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage production CT l1', + 'original_name': 'Meter status flags active production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l1', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '1', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11272,48 +11230,43 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage production CT l2', + 'original_name': 'Meter status flags active production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '0', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -11321,8 +11274,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11331,48 +11284,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l3', + 'original_name': 'Metering status net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status', + 'unique_id': '1234_net_consumption_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -11380,8 +11334,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11390,52 +11344,58 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 0, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': None, + 'original_name': 'Metering status net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Inverter 1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_last_reported-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11445,46 +11405,57 @@ 'name': None, 'options': dict({ }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Metering status net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l2', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_last_reported-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Inverter 1 Last reported', + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1970-01-01T00:00:01+00:00', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_apparent_power-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_apparent_power', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11493,51 +11464,58 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 0, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Apparent power', + 'original_name': 'Metering status net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_apparent_power_mva', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_apparent_power-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'apparent_power', - 'friendly_name': 'Encharge 123456 Apparent power', - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.encharge_123456_apparent_power', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.0', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_battery-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_battery', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11547,47 +11525,57 @@ 'name': None, 'options': dict({ }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery', + 'original_name': 'Metering status production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_soc', - 'unit_of_measurement': '%', + 'translation_key': 'production_ct_metering_status', + 'unique_id': '1234_production_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_battery-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Encharge 123456 Battery', - 'unit_of_measurement': '%', + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.encharge_123456_battery', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '15', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_last_reported-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_last_reported', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11597,46 +11585,57 @@ 'name': None, 'options': dict({ }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Metering status production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '123456_last_reported', + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l1', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_last_reported-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Encharge 123456 Last reported', + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l1', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.encharge_123456_last_reported', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2023-09-26T23:04:07+00:00', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_power-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_power', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11645,51 +11644,58 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 0, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power', + 'original_name': 'Metering status production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_real_power_mw', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_power-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Encharge 123456 Power', - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l2', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.encharge_123456_power', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.0', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_temperature-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.encharge_123456_temperature', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11698,43 +11704,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Temperature', + 'original_name': 'Metering status production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '123456_temperature', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_temperature-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_metering_status_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'temperature', - 'friendly_name': 'Encharge 123456 Temperature', - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l3', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.encharge_123456_temperature', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '29', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_last_reported-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -11742,7 +11751,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.enpower_654321_last_reported', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11751,39 +11760,49 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Net consumption CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '654321_last_reported', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_current', + 'unique_id': '1234_net_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_last_reported-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Enpower 654321 Last reported', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.enpower_654321_last_reported', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2023-09-26T23:04:07+00:00', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_temperature-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -11791,7 +11810,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.enpower_654321_temperature', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11801,42 +11820,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Temperature', + 'original_name': 'Net consumption CT current l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '654321_temperature', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_temperature-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'temperature', - 'friendly_name': 'Enpower 654321 Temperature', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.enpower_654321_temperature', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '26.1111111111111', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_available_battery_energy-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -11844,7 +11869,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_available_battery_energy', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11854,37 +11879,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Available battery energy', + 'original_name': 'Net consumption CT current l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'available_energy', - 'unique_id': '1234_available_energy', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_available_battery_energy-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Available battery energy', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_available_battery_energy', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '525', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -11899,7 +11928,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11912,38 +11941,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption', + 'original_name': 'Net consumption CT current l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption', - 'unique_id': '1234_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_net_consumption_ct_current_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.341', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -11958,7 +11987,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -11968,41 +11997,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption l1', + 'original_name': 'Power factor net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption_phase', - 'unique_id': '1234_balanced_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_powerfactor', + 'unique_id': '1234_net_ct_powerfactor', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption l1', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '12.341', + 'state': '0.21', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12017,7 +12042,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12027,41 +12052,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption l2', + 'original_name': 'Power factor net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption_phase', - 'unique_id': '1234_balanced_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption l2', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '22.341', + 'state': '0.22', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12076,7 +12097,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12086,46 +12107,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption l3', + 'original_name': 'Power factor net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption_phase', - 'unique_id': '1234_balanced_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption l3', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '32.341', + 'state': '0.23', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -12133,7 +12152,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_battery', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12142,40 +12161,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery', + 'original_name': 'Power factor net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1234_battery_level', - 'unit_of_measurement': '%', + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Battery', - 'unit_of_measurement': '%', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_battery', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '15', + 'state': '0.24', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery_capacity-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -12183,7 +12207,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_battery_capacity', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12193,37 +12217,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Battery capacity', + 'original_name': 'Power factor production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'max_capacity', - 'unique_id': '1234_max_capacity', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor', + 'unique_id': '1234_production_ct_powerfactor', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery_capacity-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Battery capacity', - 'unit_of_measurement': , + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_battery_capacity', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3500', + 'state': '0.11', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12238,7 +12262,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_battery_discharge', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12248,41 +12272,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current battery discharge', + 'original_name': 'Power factor production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'battery_discharge', - 'unique_id': '1234_battery_discharge', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current battery discharge', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l1', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_battery_discharge', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.103', + 'state': '0.12', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12297,7 +12317,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l1', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12307,41 +12327,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current battery discharge l1', + 'original_name': 'Power factor production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'battery_discharge_phase', - 'unique_id': '1234_battery_discharge_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current battery discharge l1', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l2', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l1', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.022', + 'state': '0.13', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12356,7 +12372,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l2', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12366,41 +12382,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current battery discharge l2', + 'original_name': 'Power factor production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'battery_discharge_phase', - 'unique_id': '1234_battery_discharge_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_power_factor_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current battery discharge l2', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l3', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l2', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.033', + 'state': '0.14', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12415,7 +12427,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l3', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12428,38 +12440,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current battery discharge l3', + 'original_name': 'Production CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'battery_discharge_phase', - 'unique_id': '1234_battery_discharge_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current', + 'unique_id': '1234_production_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current battery discharge l3', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l3', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.053', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12474,7 +12486,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12487,38 +12499,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption', + 'original_name': 'Production CT current l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption', - 'unique_id': '1234_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.101', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12533,7 +12545,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12546,38 +12558,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l1', + 'original_name': 'Production CT current l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l1', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12592,7 +12604,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12605,45 +12617,43 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l2', + 'original_name': 'Production CT current l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_production_ct_current_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l2', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.031', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_energy-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -12651,7 +12661,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12661,48 +12671,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l3', + 'original_name': 'Reserve battery energy', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'reserve_energy', + 'unique_id': '1234_reserve_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_energy-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Reserve battery energy', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.051', + 'state': '0', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_level-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -12710,7 +12714,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.envoy_1234_reserve_battery_level', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12719,42 +12723,35 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption', + 'original_name': 'Reserve battery level', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption', - 'unique_id': '1234_consumption', - 'unit_of_measurement': , + 'translation_key': 'reserve_soc', + 'unique_id': '1234_reserve_soc', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_reserve_battery_level-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Envoy 1234 Reserve battery level', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.envoy_1234_reserve_battery_level', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '0', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12769,7 +12766,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12779,41 +12776,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption l1', + 'original_name': 'Voltage net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption_phase', - 'unique_id': '1234_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage', + 'unique_id': '1234_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption l1', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.324', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12828,7 +12825,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12838,41 +12835,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption l2', + 'original_name': 'Voltage net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption_phase', - 'unique_id': '1234_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption l2', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.324', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12887,7 +12884,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12897,41 +12894,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption l3', + 'original_name': 'Voltage net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption_phase', - 'unique_id': '1234_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption l3', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.324', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -12946,7 +12943,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -12956,41 +12953,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production', + 'original_name': 'Voltage net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production', - 'unique_id': '1234_production', - 'unit_of_measurement': , + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13005,7 +13002,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production_l1', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13015,41 +13012,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production l1', + 'original_name': 'Voltage production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production_phase', - 'unique_id': '1234_production_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage', + 'unique_id': '1234_production_ct_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production l1', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production_l1', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '111', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13064,7 +13061,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production_l2', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13074,41 +13071,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production l2', + 'original_name': 'Voltage production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production_phase', - 'unique_id': '1234_production_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production l2', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production_l2', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.234', + 'state': '111', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13123,7 +13120,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production_l3', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13133,46 +13130,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production l3', + 'original_name': 'Voltage production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production_phase', - 'unique_id': '1234_production_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production l3', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production_l3', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.234', + 'state': '111', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days-entry] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -13180,7 +13179,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13193,42 +13192,45 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days', + 'original_name': 'Voltage production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption', - 'unique_id': '1234_seven_days_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days-state] +# name: test_sensor[envoy_eu_batt][sensor.envoy_1234_voltage_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days', - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '111', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -13236,7 +13238,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', + 'entity_id': 'sensor.inverter_1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13246,45 +13248,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days l1', + 'original_name': None, 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption_phase', - 'unique_id': '1234_seven_days_consumption_l1', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days l1', - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Inverter 1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', + 'entity_id': 'sensor.inverter_1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.321', + 'state': '1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_ac_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -13292,7 +13294,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13302,45 +13304,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days l2', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption_phase', - 'unique_id': '1234_seven_days_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_ac_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days l2', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Inverter 1 AC current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', + 'entity_id': 'sensor.inverter_1_ac_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.321', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_ac_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -13348,7 +13350,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13358,46 +13360,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days l3', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption_phase', - 'unique_id': '1234_seven_days_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_ac_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days l3', - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 AC voltage', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.321', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_dc_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -13406,7 +13406,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13416,47 +13416,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption', - 'unique_id': '1234_daily_consumption', - 'unit_of_measurement': , + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_dc_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Inverter 1 DC current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.inverter_1_dc_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_dc_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -13465,7 +13462,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13475,47 +13472,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today l1', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption_phase', - 'unique_id': '1234_daily_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_dc_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 DC voltage', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.323', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -13524,7 +13518,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13534,41 +13528,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today l2', + 'original_name': 'Energy produced since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption_phase', - 'unique_id': '1234_daily_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.323', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13583,7 +13574,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13593,46 +13584,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today l3', + 'original_name': 'Energy produced today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption_phase', - 'unique_id': '1234_daily_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today l3', + 'friendly_name': 'Inverter 1 Energy produced today', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.323', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_frequency-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -13640,7 +13630,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13650,53 +13640,53 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production', - 'unique_id': '1234_seven_days_production', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_frequency-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days', - 'unit_of_measurement': , + 'device_class': 'frequency', + 'friendly_name': 'Inverter 1 Frequency', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.inverter_1_frequency', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_last_report_duration-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_last_report_duration', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13706,40 +13696,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days l1', + 'original_name': 'Last report duration', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production_phase', - 'unique_id': '1234_seven_days_production_l1', - 'unit_of_measurement': , + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_last_report_duration-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days l1', - 'unit_of_measurement': , + 'device_class': 'duration', + 'friendly_name': 'Inverter 1 Last report duration', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', + 'entity_id': 'sensor.inverter_1_last_report_duration', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.231', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l2-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13752,7 +13740,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', + 'entity_id': 'sensor.inverter_1_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13761,46 +13749,41 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days l2', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production_phase', - 'unique_id': '1234_seven_days_production_l2', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l2-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days l2', - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Inverter 1 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', + 'entity_id': 'sensor.inverter_1_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.231', + 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l3-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_energy_produced-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -13808,7 +13791,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13818,7 +13801,7 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ 'suggested_unit_of_measurement': , @@ -13826,38 +13809,39 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days l3', + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production_phase', - 'unique_id': '1234_seven_days_production_l3', + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l3-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_energy_produced-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days l3', + 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.231', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_maximum_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -13865,8 +13849,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13876,47 +13860,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today', + 'original_name': 'Lifetime maximum power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production', - 'unique_id': '1234_daily_production', - 'unit_of_measurement': , + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_maximum_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Inverter 1 Lifetime maximum power', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l1-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -13924,8 +13905,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13935,48 +13916,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today l1', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production_phase', - 'unique_id': '1234_daily_production_l1', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l1-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'temperature', + 'friendly_name': 'Inverter 1 Temperature', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', + 'entity_id': 'sensor.inverter_1_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.233', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_apparent_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -13984,7 +13960,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', + 'entity_id': 'sensor.encharge_123456_apparent_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13994,48 +13970,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today l2', + 'original_name': 'Apparent power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production_phase', - 'unique_id': '1234_daily_production_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_apparent_power_mva', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_apparent_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'apparent_power', + 'friendly_name': 'Encharge 123456 Apparent power', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', + 'entity_id': 'sensor.encharge_123456_apparent_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.233', + 'state': '0.0', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_battery-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14043,7 +14013,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', + 'entity_id': 'sensor.encharge_123456_battery', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14052,49 +14022,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today l3', + 'original_name': 'Battery', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production_phase', - 'unique_id': '1234_daily_production_l3', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_soc', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_battery-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Encharge 123456 Battery', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', + 'entity_id': 'sensor.encharge_123456_battery', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.233', + 'state': '15', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14102,7 +14063,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.encharge_123456_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14111,46 +14072,39 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency', - 'unique_id': '1234_frequency', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '123456_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Encharge 123456 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.encharge_123456_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '2023-09-26T23:04:07+00:00', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14158,7 +14112,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.encharge_123456_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14168,45 +14122,42 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l1', + 'original_name': 'Power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l1', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_real_power_mw', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Encharge 123456 Power', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.encharge_123456_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '0.0', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14214,7 +14165,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.encharge_123456_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14227,42 +14178,39 @@ 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l2', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '123456_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.encharge_123456_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'temperature', + 'friendly_name': 'Encharge 123456 Temperature', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.encharge_123456_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '29', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14270,7 +14218,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.enpower_654321_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14279,46 +14227,39 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l3', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '654321_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Enpower 654321 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.enpower_654321_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '2023-09-26T23:04:07+00:00', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14326,7 +14267,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.enpower_654321_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14339,42 +14280,39 @@ 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency', - 'unique_id': '1234_production_ct_frequency', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '654321_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.enpower_654321_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'temperature', + 'friendly_name': 'Enpower 654321 Temperature', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.enpower_654321_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '26.1111111111111', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_available_battery_energy-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14382,7 +14320,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_available_battery_energy', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14392,38 +14330,37 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l1', + 'original_name': 'Available battery energy', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l1', - 'unit_of_measurement': , + 'translation_key': 'available_energy', + 'unique_id': '1234_available_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_available_battery_energy-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Available battery energy', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_available_battery_energy', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '525', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -14438,7 +14375,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14448,38 +14385,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l2', + 'original_name': 'Balanced net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l2', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption', + 'unique_id': '1234_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l2', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '2.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -14494,7 +14434,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14504,38 +14444,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l3', + 'original_name': 'Balanced net power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption_phase', + 'unique_id': '1234_balanced_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l3', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '12.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -14550,7 +14493,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14560,38 +14503,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency storage CT', + 'original_name': 'Balanced net power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_frequency', - 'unique_id': '1234_storage_ct_frequency', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption_phase', + 'unique_id': '1234_balanced_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency storage CT', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.3', + 'state': '22.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -14606,7 +14552,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l1', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14616,45 +14562,46 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency storage CT l1', + 'original_name': 'Balanced net power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_frequency_phase', - 'unique_id': '1234_storage_ct_frequency_l1', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption_phase', + 'unique_id': '1234_balanced_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_balanced_net_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency storage CT l1', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l1', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.3', + 'state': '32.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14662,7 +14609,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l2', + 'entity_id': 'sensor.envoy_1234_battery', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14671,46 +14618,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency storage CT l2', + 'original_name': 'Battery', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_frequency_phase', - 'unique_id': '1234_storage_ct_frequency_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1234_battery_level', + 'unit_of_measurement': '%', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency storage CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'battery', + 'friendly_name': 'Envoy 1234 Battery', + 'unit_of_measurement': '%', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l2', + 'entity_id': 'sensor.envoy_1234_battery', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '15', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery_capacity-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -14718,7 +14659,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l3', + 'entity_id': 'sensor.envoy_1234_battery_capacity', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14728,44 +14669,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency storage CT l3', + 'original_name': 'Battery capacity', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_frequency_phase', - 'unique_id': '1234_storage_ct_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'max_capacity', + 'unique_id': '1234_max_capacity', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_battery_capacity-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency storage CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Battery capacity', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l3', + 'entity_id': 'sensor.envoy_1234_battery_capacity', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '3500', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -14774,7 +14714,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14787,44 +14727,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption', + 'original_name': 'Current battery discharge', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption', - 'unique_id': '1234_lifetime_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'battery_discharge', + 'unique_id': '1234_battery_discharge', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current battery discharge', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4.321', + 'state': '0.103', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -14833,7 +14773,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14846,44 +14786,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption l1', + 'original_name': 'Current battery discharge l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption_phase', - 'unique_id': '1234_lifetime_balanced_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'battery_discharge_phase', + 'unique_id': '1234_battery_discharge_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current battery discharge l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.321', + 'state': '0.022', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -14892,7 +14832,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14905,44 +14845,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption l2', + 'original_name': 'Current battery discharge l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption_phase', - 'unique_id': '1234_lifetime_balanced_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'battery_discharge_phase', + 'unique_id': '1234_battery_discharge_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current battery discharge l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.321', + 'state': '0.033', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -14951,7 +14891,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -14964,44 +14904,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption l3', + 'original_name': 'Current battery discharge l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption_phase', - 'unique_id': '1234_lifetime_balanced_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'battery_discharge_phase', + 'unique_id': '1234_battery_discharge_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_battery_discharge_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current battery discharge l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_current_battery_discharge_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.321', + 'state': '0.053', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15010,7 +14950,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15023,44 +14963,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy charged', + 'original_name': 'Current net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_charged', - 'unique_id': '1234_lifetime_battery_charged', - 'unit_of_measurement': , + 'translation_key': 'net_consumption', + 'unique_id': '1234_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy charged', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.032345', + 'state': '0.101', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15069,7 +15009,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l1', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15082,44 +15022,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy charged l1', + 'original_name': 'Current net power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_charged_phase', - 'unique_id': '1234_lifetime_battery_charged_l1', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy charged l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l1', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.323451', + 'state': '0.021', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15128,7 +15068,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l2', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15141,44 +15081,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy charged l2', + 'original_name': 'Current net power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_charged_phase', - 'unique_id': '1234_lifetime_battery_charged_l2', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy charged l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l2', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.323452', + 'state': '0.031', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15187,7 +15127,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l3', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15200,44 +15140,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy charged l3', + 'original_name': 'Current net power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_charged_phase', - 'unique_id': '1234_lifetime_battery_charged_l3', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_net_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy charged l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l3', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.323453', + 'state': '0.051', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15246,7 +15186,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15259,44 +15199,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy discharged', + 'original_name': 'Current power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_discharged', - 'unique_id': '1234_lifetime_battery_discharged', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption', + 'unique_id': '1234_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.031234', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15305,7 +15245,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l1', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15318,44 +15258,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy discharged l1', + 'original_name': 'Current power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_discharged_phase', - 'unique_id': '1234_lifetime_battery_discharged_l1', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption_phase', + 'unique_id': '1234_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l1', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.312341', + 'state': '1.324', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15364,7 +15304,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l2', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15377,44 +15317,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy discharged l2', + 'original_name': 'Current power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_discharged_phase', - 'unique_id': '1234_lifetime_battery_discharged_l2', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption_phase', + 'unique_id': '1234_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l2', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.312342', + 'state': '2.324', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15423,7 +15363,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l3', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15436,44 +15376,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime battery energy discharged l3', + 'original_name': 'Current power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_battery_discharged_phase', - 'unique_id': '1234_lifetime_battery_discharged_l3', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption_phase', + 'unique_id': '1234_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l3', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.312343', + 'state': '3.324', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15482,7 +15422,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15495,44 +15435,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption', + 'original_name': 'Current power production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption', - 'unique_id': '1234_lifetime_consumption', - 'unit_of_measurement': , + 'translation_key': 'current_power_production', + 'unique_id': '1234_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15541,7 +15481,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_current_power_production_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15554,44 +15494,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption l1', + 'original_name': 'Current power production l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption_phase', - 'unique_id': '1234_lifetime_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'current_power_production_phase', + 'unique_id': '1234_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_current_power_production_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001322', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15600,7 +15540,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_current_power_production_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15613,44 +15553,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption l2', + 'original_name': 'Current power production l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption_phase', - 'unique_id': '1234_lifetime_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'current_power_production_phase', + 'unique_id': '1234_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_current_power_production_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.002322', + 'state': '2.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -15659,7 +15599,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_current_power_production_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15672,45 +15612,43 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption l3', + 'original_name': 'Current power production l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption_phase', - 'unique_id': '1234_lifetime_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'current_power_production_phase', + 'unique_id': '1234_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_current_power_production_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_current_power_production_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.003322', + 'state': '3.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -15718,7 +15656,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15728,48 +15666,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production', + 'original_name': 'Energy consumption last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production', - 'unique_id': '1234_lifetime_production', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption', + 'unique_id': '1234_seven_days_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy consumption last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -15777,7 +15712,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15787,48 +15722,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production l1', + 'original_name': 'Energy consumption last seven days l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production_phase', - 'unique_id': '1234_lifetime_production_l1', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption_phase', + 'unique_id': '1234_seven_days_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production l1', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy consumption last seven days l1', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001232', + 'state': '1.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -15836,7 +15768,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15846,48 +15778,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production l2', + 'original_name': 'Energy consumption last seven days l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production_phase', - 'unique_id': '1234_lifetime_production_l2', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption_phase', + 'unique_id': '1234_seven_days_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy consumption last seven days l2', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.002232', + 'state': '2.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -15895,7 +15824,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15905,41 +15834,40 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production l3', + 'original_name': 'Energy consumption last seven days l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production_phase', - 'unique_id': '1234_lifetime_production_l3', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption_phase', + 'unique_id': '1234_seven_days_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_last_seven_days_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production l3', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy consumption last seven days l3', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.003232', + 'state': '3.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -15954,7 +15882,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -15964,41 +15892,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption', + 'original_name': 'Energy consumption today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption', - 'unique_id': '1234_lifetime_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'daily_consumption', + 'unique_id': '1234_daily_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', + 'friendly_name': 'Envoy 1234 Energy consumption today', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021234', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -16013,7 +15941,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16023,41 +15951,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l1', + 'original_name': 'Energy consumption today l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'daily_consumption_phase', + 'unique_id': '1234_daily_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', + 'friendly_name': 'Envoy 1234 Energy consumption today l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212341', + 'state': '1.323', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -16072,7 +16000,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16082,41 +16010,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l2', + 'original_name': 'Energy consumption today l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'daily_consumption_phase', + 'unique_id': '1234_daily_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', + 'friendly_name': 'Envoy 1234 Energy consumption today l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212342', + 'state': '2.323', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -16131,7 +16059,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16141,48 +16069,46 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l3', + 'original_name': 'Energy consumption today l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'daily_consumption_phase', + 'unique_id': '1234_daily_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_consumption_today_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', + 'friendly_name': 'Envoy 1234 Energy consumption today l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212343', + 'state': '3.323', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -16190,7 +16116,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16200,48 +16126,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production', + 'original_name': 'Energy production last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production', - 'unique_id': '1234_lifetime_net_production', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production', + 'unique_id': '1234_seven_days_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy production last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.022345', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -16249,7 +16172,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16259,48 +16182,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l1', + 'original_name': 'Energy production last seven days l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l1', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production_phase', + 'unique_id': '1234_seven_days_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy production last seven days l1', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223451', + 'state': '1.231', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -16308,7 +16228,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16318,48 +16238,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l2', + 'original_name': 'Energy production last seven days l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l2', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production_phase', + 'unique_id': '1234_seven_days_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy production last seven days l2', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223452', + 'state': '2.231', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -16367,7 +16284,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16377,54 +16294,55 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l3', + 'original_name': 'Energy production last seven days l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l3', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production_phase', + 'unique_id': '1234_seven_days_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_last_seven_days_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Energy production last seven days l3', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223453', + 'state': '3.231', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, - 'config_entry_id': , - 'config_subentry_id': , + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16433,46 +16351,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags', - 'unique_id': '1234_net_consumption_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'daily_production', + 'unique_id': '1234_daily_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16481,46 +16410,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l1', + 'original_name': 'Energy production today l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l1', - 'unit_of_measurement': None, + 'translation_key': 'daily_production_phase', + 'unique_id': '1234_daily_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '1.233', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16529,46 +16469,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l2', + 'original_name': 'Energy production today l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l2', - 'unit_of_measurement': None, + 'translation_key': 'daily_production_phase', + 'unique_id': '1234_daily_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '2.233', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16577,46 +16528,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l3', + 'original_name': 'Energy production today l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'daily_production_phase', + 'unique_id': '1234_daily_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_energy_production_today_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '3.233', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16625,46 +16587,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT', + 'original_name': 'Frequency net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags', - 'unique_id': '1234_production_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency', + 'unique_id': '1234_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16673,46 +16643,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l1', + 'original_name': 'Frequency net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l1', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16721,46 +16699,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l2', + 'original_name': 'Frequency net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l2', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16769,46 +16755,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l3', + 'original_name': 'Frequency net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16817,46 +16811,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active storage CT', + 'original_name': 'Frequency production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_status_flags', - 'unique_id': '1234_storage_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency', + 'unique_id': '1234_production_ct_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active storage CT', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16865,46 +16867,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active storage CT l1', + 'original_name': 'Frequency production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_status_flags_phase', - 'unique_id': '1234_storage_ct_status_flags_l1', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active storage CT l1', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l1', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16913,46 +16923,54 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active storage CT l2', + 'original_name': 'Frequency production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_status_flags_phase', - 'unique_id': '1234_storage_ct_status_flags_l2', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active storage CT l2', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l2', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -16961,43 +16979,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active storage CT l3', + 'original_name': 'Frequency production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_status_flags_phase', - 'unique_id': '1234_storage_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active storage CT l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17005,8 +17025,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17015,49 +17035,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT', + 'original_name': 'Frequency storage CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status', - 'unique_id': '1234_net_consumption_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'storage_ct_frequency', + 'unique_id': '1234_storage_ct_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency storage CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.3', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17065,8 +17081,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17075,49 +17091,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l1', + 'original_name': 'Frequency storage CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'storage_ct_frequency_phase', + 'unique_id': '1234_storage_ct_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency storage CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.3', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17125,8 +17137,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17135,49 +17147,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l2', + 'original_name': 'Frequency storage CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'storage_ct_frequency_phase', + 'unique_id': '1234_storage_ct_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency storage CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17185,8 +17193,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17195,49 +17203,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l3', + 'original_name': 'Frequency storage CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'storage_ct_frequency_phase', + 'unique_id': '1234_storage_ct_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_frequency_storage_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency storage CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_storage_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17245,8 +17249,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17255,49 +17259,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT', + 'original_name': 'Lifetime balanced net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status', - 'unique_id': '1234_production_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_balanced_net_consumption', + 'unique_id': '1234_lifetime_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '4.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17305,8 +17308,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17315,49 +17318,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l1', + 'original_name': 'Lifetime balanced net energy consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_balanced_net_consumption_phase', + 'unique_id': '1234_lifetime_balanced_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '1.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17365,8 +17367,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17375,49 +17377,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l2', + 'original_name': 'Lifetime balanced net energy consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_balanced_net_consumption_phase', + 'unique_id': '1234_lifetime_balanced_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '2.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17425,8 +17426,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17435,49 +17436,4290 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l3', + 'original_name': 'Lifetime balanced net energy consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_balanced_net_consumption_phase', + 'unique_id': '1234_lifetime_balanced_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '3.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy charged', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_charged', + 'unique_id': '1234_lifetime_battery_charged', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy charged', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.032345', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy charged l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_charged_phase', + 'unique_id': '1234_lifetime_battery_charged_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy charged l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.323451', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy charged l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_charged_phase', + 'unique_id': '1234_lifetime_battery_charged_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy charged l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.323452', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy charged l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_charged_phase', + 'unique_id': '1234_lifetime_battery_charged_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_charged_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy charged l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_charged_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.323453', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy discharged', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_discharged', + 'unique_id': '1234_lifetime_battery_discharged', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.031234', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy discharged l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_discharged_phase', + 'unique_id': '1234_lifetime_battery_discharged_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.312341', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy discharged l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_discharged_phase', + 'unique_id': '1234_lifetime_battery_discharged_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.312342', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime battery energy discharged l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_battery_discharged_phase', + 'unique_id': '1234_lifetime_battery_discharged_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_battery_energy_discharged_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime battery energy discharged l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_battery_energy_discharged_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.312343', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy consumption', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_consumption', + 'unique_id': '1234_lifetime_consumption', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.001234', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy consumption l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_consumption_phase', + 'unique_id': '1234_lifetime_consumption_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.001322', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy consumption l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_consumption_phase', + 'unique_id': '1234_lifetime_consumption_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.002322', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy consumption l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_consumption_phase', + 'unique_id': '1234_lifetime_consumption_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_consumption_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.003322', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy production', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_production', + 'unique_id': '1234_lifetime_production', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.001234', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy production l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_production_phase', + 'unique_id': '1234_lifetime_production_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.001232', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy production l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_production_phase', + 'unique_id': '1234_lifetime_production_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.002232', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime energy production l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_production_phase', + 'unique_id': '1234_lifetime_production_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_energy_production_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.003232', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy consumption', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_consumption', + 'unique_id': '1234_lifetime_net_consumption', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.021234', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy consumption l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.212341', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy consumption l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.212342', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy consumption l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.212343', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy production', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_production', + 'unique_id': '1234_lifetime_net_production', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.022345', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy production l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.223451', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy production l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.223452', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Lifetime net energy production l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_lifetime_net_energy_production_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.223453', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active net consumption CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_status_flags', + 'unique_id': '1234_net_consumption_ct_status_flags', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active net consumption CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active net consumption CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active net consumption CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active production CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_status_flags', + 'unique_id': '1234_production_ct_status_flags', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active production CT', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '2', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active production CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active production CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active production CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active storage CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_status_flags', + 'unique_id': '1234_storage_ct_status_flags', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active storage CT', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active storage CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_status_flags_phase', + 'unique_id': '1234_storage_ct_status_flags_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active storage CT l1', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active storage CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_status_flags_phase', + 'unique_id': '1234_storage_ct_status_flags_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active storage CT l2', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Meter status flags active storage CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_status_flags_phase', + 'unique_id': '1234_storage_ct_status_flags_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_meter_status_flags_active_storage_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active storage CT l3', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_storage_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status net consumption CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_metering_status', + 'unique_id': '1234_net_consumption_ct_metering_status', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status net consumption CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status net consumption CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status net consumption CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status production CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_metering_status', + 'unique_id': '1234_production_ct_metering_status', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status production CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l1', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status production CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l2', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status production CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_production_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l3', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status storage CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_metering_status', + 'unique_id': '1234_storage_ct_metering_status', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status storage CT', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status storage CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_metering_status_phase', + 'unique_id': '1234_storage_ct_metering_status_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status storage CT l1', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status storage CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_metering_status_phase', + 'unique_id': '1234_storage_ct_metering_status_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status storage CT l2', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'options': list([ + , + , + , + ]), + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Metering status storage CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_metering_status_phase', + 'unique_id': '1234_storage_ct_metering_status_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status storage CT l3', + 'options': list([ + , + , + , + ]), + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'normal', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Net consumption CT current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_current', + 'unique_id': '1234_net_ct_current', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.3', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Net consumption CT current l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.3', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Net consumption CT current l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.3', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Net consumption CT current l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.3', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor net consumption CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_powerfactor', + 'unique_id': '1234_net_ct_powerfactor', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.21', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor net consumption CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.22', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor net consumption CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.23', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor net consumption CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.24', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor production CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_powerfactor', + 'unique_id': '1234_production_ct_powerfactor', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.11', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor production CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l1', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.12', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor production CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l2', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.13', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor production CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l3', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.14', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor storage CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_powerfactor', + 'unique_id': '1234_storage_ct_powerfactor', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor storage CT', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.23', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor storage CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_powerfactor_phase', + 'unique_id': '1234_storage_ct_powerfactor_l1', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor storage CT l1', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.32', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor storage CT l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_powerfactor_phase', + 'unique_id': '1234_storage_ct_powerfactor_l2', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor storage CT l2', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.23', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Power factor storage CT l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_powerfactor_phase', + 'unique_id': '1234_storage_ct_powerfactor_l3', + 'unit_of_measurement': None, + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor storage CT l3', + 'state_class': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.24', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Production CT current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_current', + 'unique_id': '1234_production_ct_current', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.2', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Production CT current l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.2', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Production CT current l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.2', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Production CT current l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.2', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_energy-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Reserve battery energy', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'reserve_energy', + 'unique_id': '1234_reserve_energy', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_energy-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Reserve battery energy', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '526', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_level-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Reserve battery level', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'reserve_soc', + 'unique_id': '1234_reserve_soc', + 'unit_of_measurement': '%', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_level-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'battery', + 'friendly_name': 'Envoy 1234 Reserve battery level', + 'unit_of_measurement': '%', + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '15', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_storage_ct_current', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Storage CT current', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_current', + 'unique_id': '1234_storage_ct_current', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Storage CT current', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_storage_ct_current', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.4', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_storage_ct_current_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Storage CT current l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_current_phase', + 'unique_id': '1234_storage_ct_current_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Storage CT current l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_storage_ct_current_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.4', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l2-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_storage_ct_current_l2', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Storage CT current l2', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_current_phase', + 'unique_id': '1234_storage_ct_current_l2', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l2-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Storage CT current l2', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_storage_ct_current_l2', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.3', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l3-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_storage_ct_current_l3', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Storage CT current l3', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'storage_ct_current_phase', + 'unique_id': '1234_storage_ct_current_l3', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l3-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Storage CT current l3', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_storage_ct_current_l3', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.3', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Voltage net consumption CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'net_ct_voltage', + 'unique_id': '1234_voltage', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '112', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17485,8 +21727,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17495,49 +21737,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status storage CT', + 'original_name': 'Voltage net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_metering_status', - 'unique_id': '1234_storage_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status storage CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17545,8 +21786,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17555,49 +21796,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status storage CT l1', + 'original_name': 'Voltage net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_metering_status_phase', - 'unique_id': '1234_storage_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status storage CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l1', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17605,8 +21845,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17615,49 +21855,166 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status storage CT l2', + 'original_name': 'Voltage net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_metering_status_phase', - 'unique_id': '1234_storage_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status storage CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l2', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Voltage production CT', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_voltage', + 'unique_id': '1234_production_ct_voltage', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '111', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l1-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': dict({ + 'state_class': , + }), + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Voltage production CT l1', + 'platform': 'enphase_envoy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l1', + 'unit_of_measurement': , + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l1-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l1', + 'state_class': , + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '111', + }) +# --- +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -17665,8 +22022,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17675,39 +22032,42 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status storage CT l3', + 'original_name': 'Voltage production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_metering_status_phase', - 'unique_id': '1234_storage_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_metering_status_storage_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status storage CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_storage_ct_l3', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '111', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -17722,7 +22082,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17732,41 +22092,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current', + 'original_name': 'Voltage production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current', - 'unique_id': '1234_net_ct_current', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '111', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -17781,7 +22141,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17791,41 +22151,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l1', + 'original_name': 'Voltage storage CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'storage_ct_voltage', + 'unique_id': '1234_storage_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l1', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage storage CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '113', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -17840,7 +22200,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17850,41 +22210,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l2', + 'original_name': 'Voltage storage CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': 'storage_ct_voltage_phase', + 'unique_id': '1234_storage_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l2', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage storage CT l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '113', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -17899,7 +22259,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17909,41 +22269,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l3', + 'original_name': 'Voltage storage CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l3', - 'unit_of_measurement': , + 'translation_key': 'storage_ct_voltage_phase', + 'unique_id': '1234_storage_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_net_consumption_ct_current_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l3', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage storage CT l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -17958,7 +22318,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -17968,37 +22328,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT', + 'original_name': 'Voltage storage CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor', - 'unique_id': '1234_net_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'storage_ct_voltage_phase', + 'unique_id': '1234_storage_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage storage CT l3', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.21', + 'state': '112', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18013,7 +22377,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.inverter_1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18023,37 +22387,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l1', + 'original_name': None, 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', + 'device_class': 'power', + 'friendly_name': 'Inverter 1', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.inverter_1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.22', + 'state': '1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_ac_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18068,7 +22433,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18078,37 +22443,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l2', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l2', - 'unit_of_measurement': None, + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_ac_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 AC current', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_id': 'sensor.inverter_1_ac_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.23', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_ac_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18123,7 +22489,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18133,37 +22499,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l3', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l3', - 'unit_of_measurement': None, + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_ac_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 AC voltage', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.24', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_dc_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18178,7 +22545,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18188,37 +22555,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor', - 'unique_id': '1234_production_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_dc_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 DC current', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.inverter_1_dc_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.11', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_dc_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18233,7 +22601,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18243,43 +22611,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l1', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_dc_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l1', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 DC voltage', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.12', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -18288,7 +22657,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18298,43 +22667,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l2', + 'original_name': 'Energy produced since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l2', - 'unit_of_measurement': None, + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l2', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.13', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -18343,7 +22713,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18353,37 +22723,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l3', + 'original_name': 'Energy produced today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l3', - 'unit_of_measurement': None, + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_production_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l3', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.14', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_frequency-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18398,7 +22769,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct', + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18408,37 +22779,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor storage CT', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_powerfactor', - 'unique_id': '1234_storage_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_frequency-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor storage CT', + 'device_class': 'frequency', + 'friendly_name': 'Inverter 1 Frequency', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct', + 'entity_id': 'sensor.inverter_1_frequency', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.23', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_last_report_duration-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18452,8 +22824,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_last_report_duration', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18466,41 +22838,40 @@ 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor storage CT l1', + 'original_name': 'Last report duration', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_powerfactor_phase', - 'unique_id': '1234_storage_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_last_report_duration-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor storage CT l1', + 'device_class': 'duration', + 'friendly_name': 'Inverter 1 Last report duration', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l1', + 'entity_id': 'sensor.inverter_1_last_report_duration', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.32', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l2-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -18508,7 +22879,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l2', + 'entity_id': 'sensor.inverter_1_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18517,44 +22888,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor storage CT l2', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_powerfactor_phase', - 'unique_id': '1234_storage_ct_powerfactor_l2', + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l2-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor storage CT l2', - 'state_class': , + 'device_class': 'timestamp', + 'friendly_name': 'Inverter 1 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l2', + 'entity_id': 'sensor.inverter_1_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.23', + 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l3-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_energy_produced-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -18563,7 +22930,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l3', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18575,35 +22942,39 @@ 'sensor': dict({ 'suggested_display_precision': 2, }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor storage CT l3', + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_powerfactor_phase', - 'unique_id': '1234_storage_ct_powerfactor_l3', - 'unit_of_measurement': None, + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_power_factor_storage_ct_l3-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_energy_produced-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor storage CT l3', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_storage_ct_l3', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.24', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_maximum_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18617,8 +22988,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18628,41 +22999,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current', + 'original_name': 'Lifetime maximum power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current', - 'unique_id': '1234_production_ct_current', - 'unit_of_measurement': , + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_maximum_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current', + 'device_class': 'power', + 'friendly_name': 'Inverter 1 Lifetime maximum power', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '1', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l1-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18676,8 +23044,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18689,39 +23057,36 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l1', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l1-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l1', + 'device_class': 'temperature', + 'friendly_name': 'Inverter 1 Temperature', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_id': 'sensor.inverter_1_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18736,7 +23101,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18749,38 +23114,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l2', + 'original_name': 'Balanced net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption', + 'unique_id': '1234_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l2', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '2.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18795,7 +23160,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18808,43 +23173,45 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l3', + 'original_name': 'Balanced net power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, - 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l3', - 'unit_of_measurement': , + 'supported_features': 0, + 'translation_key': 'balanced_net_consumption_phase', + 'unique_id': '1234_balanced_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_production_ct_current_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l3', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '12.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_energy-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -18852,7 +23219,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18862,42 +23229,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Reserve battery energy', + 'original_name': 'Balanced net power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'reserve_energy', - 'unique_id': '1234_reserve_energy', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption_phase', + 'unique_id': '1234_balanced_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_energy-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Reserve battery energy', - 'unit_of_measurement': , + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_reserve_battery_energy', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '526', + 'state': '22.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_level-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -18905,7 +23278,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18914,35 +23287,42 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Reserve battery level', + 'original_name': 'Balanced net power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'reserve_soc', - 'unique_id': '1234_reserve_soc', - 'unit_of_measurement': '%', + 'translation_key': 'balanced_net_consumption_phase', + 'unique_id': '1234_balanced_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_reserve_battery_level-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Reserve battery level', - 'unit_of_measurement': '%', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_reserve_battery_level', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '15', + 'state': '32.341', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -18957,7 +23337,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_storage_ct_current', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -18970,38 +23350,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Storage CT current', + 'original_name': 'Current net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_current', - 'unique_id': '1234_storage_ct_current', - 'unit_of_measurement': , + 'translation_key': 'net_consumption', + 'unique_id': '1234_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Storage CT current', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_storage_ct_current', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.4', + 'state': '0.101', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19016,7 +23396,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_storage_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19029,38 +23409,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Storage CT current l1', + 'original_name': 'Current net power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_current_phase', - 'unique_id': '1234_storage_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Storage CT current l1', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_storage_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.4', + 'state': '0.021', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19075,7 +23455,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_storage_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19088,38 +23468,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Storage CT current l2', + 'original_name': 'Current net power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_current_phase', - 'unique_id': '1234_storage_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Storage CT current l2', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_storage_ct_current_l2', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '0.031', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19134,7 +23514,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_storage_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19147,38 +23527,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Storage CT current l3', + 'original_name': 'Current net power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_current_phase', - 'unique_id': '1234_storage_ct_current_l3', - 'unit_of_measurement': , + 'translation_key': 'net_consumption_phase', + 'unique_id': '1234_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_storage_ct_current_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Storage CT current l3', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current net power consumption l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_storage_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '0.051', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19193,7 +23573,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19203,41 +23583,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT', + 'original_name': 'Current power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage', - 'unique_id': '1234_voltage', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption', + 'unique_id': '1234_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_current_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19252,7 +23632,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19262,41 +23642,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l1', + 'original_name': 'Current power consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption_phase', + 'unique_id': '1234_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '1.324', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19311,7 +23691,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19321,41 +23701,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l2', + 'original_name': 'Current power consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption_phase', + 'unique_id': '1234_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '2.324', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19370,7 +23750,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19380,41 +23760,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l3', + 'original_name': 'Current power consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'current_power_consumption_phase', + 'unique_id': '1234_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power consumption l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '3.324', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19429,7 +23809,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19439,41 +23819,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT', + 'original_name': 'Current power production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage', - 'unique_id': '1234_production_ct_voltage', - 'unit_of_measurement': , + 'translation_key': 'current_power_production', + 'unique_id': '1234_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19488,7 +23868,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_current_power_production_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19498,41 +23878,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l1', + 'original_name': 'Current power production l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'current_power_production_phase', + 'unique_id': '1234_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l1', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_current_power_production_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19547,7 +23927,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_current_power_production_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19557,41 +23937,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l2', + 'original_name': 'Current power production l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'current_power_production_phase', + 'unique_id': '1234_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l2', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_current_power_production_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '2.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -19606,7 +23986,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_current_power_production_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19616,48 +23996,46 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l3', + 'original_name': 'Current power production l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'current_power_production_phase', + 'unique_id': '1234_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_production_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l3', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_current_power_production_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '3.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -19665,7 +24043,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19678,45 +24056,42 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage storage CT', + 'original_name': 'Energy consumption last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_voltage', - 'unique_id': '1234_storage_voltage', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption', + 'unique_id': '1234_seven_days_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage storage CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '113', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -19724,7 +24099,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19737,45 +24112,42 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage storage CT l1', + 'original_name': 'Energy consumption last seven days l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_voltage_phase', - 'unique_id': '1234_storage_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption_phase', + 'unique_id': '1234_seven_days_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage storage CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption last seven days l1', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '113', + 'state': '1.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -19783,7 +24155,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l2', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19796,45 +24168,42 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage storage CT l2', + 'original_name': 'Energy consumption last seven days l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_voltage_phase', - 'unique_id': '1234_storage_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption_phase', + 'unique_id': '1234_seven_days_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage storage CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption last seven days l2', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l2', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '2.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -19842,7 +24211,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19855,44 +24224,43 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage storage CT l3', + 'original_name': 'Energy consumption last seven days l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'storage_ct_voltage_phase', - 'unique_id': '1234_storage_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'seven_days_consumption_phase', + 'unique_id': '1234_seven_days_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.envoy_1234_voltage_storage_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage storage CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption last seven days l3', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_storage_ct_l3', + 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '3.321', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -19901,7 +24269,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19911,43 +24279,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': None, + 'original_name': 'Energy consumption today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', - 'unit_of_measurement': , + 'translation_key': 'daily_consumption', + 'unique_id': '1234_daily_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Inverter 1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_last_reported-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -19955,7 +24328,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -19964,40 +24337,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Energy consumption today l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', - 'unit_of_measurement': None, + 'translation_key': 'daily_consumption_phase', + 'unique_id': '1234_daily_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_last_reported-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Inverter 1 Last reported', + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption today l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1970-01-01T00:00:01+00:00', + 'state': '1.323', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -20006,7 +24387,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20016,47 +24397,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption', + 'original_name': 'Energy consumption today l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption', - 'unique_id': '1234_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'daily_consumption_phase', + 'unique_id': '1234_daily_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption today l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.341', + 'state': '2.323', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -20065,7 +24446,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20075,48 +24456,46 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption l1', + 'original_name': 'Energy consumption today l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption_phase', - 'unique_id': '1234_balanced_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'daily_consumption_phase', + 'unique_id': '1234_daily_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy consumption today l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '12.341', + 'state': '3.323', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -20124,7 +24503,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20134,48 +24513,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption l2', + 'original_name': 'Energy production last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption_phase', - 'unique_id': '1234_balanced_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production', + 'unique_id': '1234_seven_days_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '22.341', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -20183,7 +24559,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20193,48 +24569,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption l3', + 'original_name': 'Energy production last seven days l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, - 'suggested_object_id': None, - 'supported_features': 0, - 'translation_key': 'balanced_net_consumption_phase', - 'unique_id': '1234_balanced_net_consumption_l3', - 'unit_of_measurement': , + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': 'seven_days_production_phase', + 'unique_id': '1234_seven_days_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_balanced_net_power_consumption_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days l1', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '32.341', + 'state': '1.231', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -20242,7 +24615,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20252,48 +24625,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption', + 'original_name': 'Energy production last seven days l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption', - 'unique_id': '1234_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production_phase', + 'unique_id': '1234_seven_days_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days l2', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.101', + 'state': '2.231', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -20301,7 +24671,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20311,47 +24681,46 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l1', + 'original_name': 'Energy production last seven days l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production_phase', + 'unique_id': '1234_seven_days_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days l3', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021', + 'state': '3.231', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -20360,7 +24729,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20370,47 +24739,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l2', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'daily_production', + 'unique_id': '1234_daily_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.031', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -20419,7 +24788,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20429,47 +24798,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current net power consumption l3', + 'original_name': 'Energy production today l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_consumption_phase', - 'unique_id': '1234_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'daily_production_phase', + 'unique_id': '1234_daily_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_net_power_consumption_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current net power consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_net_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.051', + 'state': '1.233', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -20478,7 +24847,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20488,47 +24857,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption', + 'original_name': 'Energy production today l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption', - 'unique_id': '1234_consumption', - 'unit_of_measurement': , + 'translation_key': 'daily_production_phase', + 'unique_id': '1234_daily_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '2.233', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -20537,7 +24906,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20547,41 +24916,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption l1', + 'original_name': 'Energy production today l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption_phase', - 'unique_id': '1234_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'daily_production_phase', + 'unique_id': '1234_daily_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.324', + 'state': '3.233', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -20596,7 +24965,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20606,41 +24975,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption l2', + 'original_name': 'Frequency net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption_phase', - 'unique_id': '1234_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_frequency', + 'unique_id': '1234_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption l2', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l2', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.324', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -20655,7 +25021,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20665,41 +25031,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power consumption l3', + 'original_name': 'Frequency net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_consumption_phase', - 'unique_id': '1234_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_consumption_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power consumption l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_consumption_l3', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.324', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -20714,7 +25077,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20724,41 +25087,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production', + 'original_name': 'Frequency net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production', - 'unique_id': '1234_production', - 'unit_of_measurement': , + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -20773,7 +25133,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production_l1', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20783,41 +25143,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production l1', + 'original_name': 'Frequency net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production_phase', - 'unique_id': '1234_production_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_frequency_phase', + 'unique_id': '1234_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production l1', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production_l1', + 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '50.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -20832,7 +25189,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production_l2', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20842,41 +25199,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production l2', + 'original_name': 'Frequency production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production_phase', - 'unique_id': '1234_production_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_frequency', + 'unique_id': '1234_production_ct_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production l2', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production_l2', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.234', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -20891,7 +25245,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20901,46 +25255,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 1, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production l3', + 'original_name': 'Frequency production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production_phase', - 'unique_id': '1234_production_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_current_power_production_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.234', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -20948,7 +25301,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -20960,43 +25313,43 @@ 'sensor': dict({ 'suggested_display_precision': 1, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days', + 'original_name': 'Frequency production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption', - 'unique_id': '1234_seven_days_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days', - 'unit_of_measurement': , + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -21004,7 +25357,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21016,43 +25369,43 @@ 'sensor': dict({ 'suggested_display_precision': 1, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days l1', + 'original_name': 'Frequency production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption_phase', - 'unique_id': '1234_seven_days_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_frequency_phase', + 'unique_id': '1234_production_ct_frequency_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days l1', - 'unit_of_measurement': , + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l1', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.321', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -21060,7 +25413,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21070,7 +25423,7 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ 'suggested_unit_of_measurement': , @@ -21078,37 +25431,40 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days l2', + 'original_name': 'Lifetime balanced net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption_phase', - 'unique_id': '1234_seven_days_consumption_l2', + 'translation_key': 'lifetime_balanced_net_consumption', + 'unique_id': '1234_lifetime_balanced_net_consumption', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days l2', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', + 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.321', + 'state': '4.321', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -21116,7 +25472,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21126,7 +25482,7 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ 'suggested_unit_of_measurement': , @@ -21134,38 +25490,39 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption last seven days l3', + 'original_name': 'Lifetime balanced net energy consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_consumption_phase', - 'unique_id': '1234_seven_days_consumption_l3', + 'translation_key': 'lifetime_balanced_net_consumption_phase', + 'unique_id': '1234_lifetime_balanced_net_consumption_l1', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_last_seven_days_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption last seven days l3', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l1', + 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_last_seven_days_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.321', + 'state': '1.321', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -21174,7 +25531,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21184,7 +25541,7 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ 'suggested_unit_of_measurement': , @@ -21192,39 +25549,39 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today', + 'original_name': 'Lifetime balanced net energy consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption', - 'unique_id': '1234_daily_consumption', + 'translation_key': 'lifetime_balanced_net_consumption_phase', + 'unique_id': '1234_lifetime_balanced_net_consumption_l2', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today', - 'state_class': , + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l2', + 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '2.321', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -21233,7 +25590,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21243,7 +25600,7 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ 'suggested_unit_of_measurement': , @@ -21251,33 +25608,33 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today l1', + 'original_name': 'Lifetime balanced net energy consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption_phase', - 'unique_id': '1234_daily_consumption_l1', + 'translation_key': 'lifetime_balanced_net_consumption_phase', + 'unique_id': '1234_lifetime_balanced_net_consumption_l3', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today l1', - 'state_class': , + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l3', + 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.323', + 'state': '3.321', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -21292,7 +25649,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21302,41 +25659,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today l2', + 'original_name': 'Lifetime energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption_phase', - 'unique_id': '1234_daily_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'lifetime_consumption', + 'unique_id': '1234_lifetime_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today l2', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.323', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -21351,7 +25708,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21361,46 +25718,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy consumption today l3', + 'original_name': 'Lifetime energy consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_consumption_phase', - 'unique_id': '1234_daily_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'lifetime_consumption_phase', + 'unique_id': '1234_lifetime_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_consumption_today_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy consumption today l3', + 'friendly_name': 'Envoy 1234 Lifetime energy consumption l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_consumption_today_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.323', + 'state': '0.001322', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -21408,7 +25767,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21418,45 +25777,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days', + 'original_name': 'Lifetime energy consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production', - 'unique_id': '1234_seven_days_production', - 'unit_of_measurement': , + 'translation_key': 'lifetime_consumption_phase', + 'unique_id': '1234_lifetime_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days', - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Lifetime energy consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '0.002322', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -21464,7 +25826,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21474,45 +25836,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days l1', + 'original_name': 'Lifetime energy consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production_phase', - 'unique_id': '1234_seven_days_production_l1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_consumption_phase', + 'unique_id': '1234_lifetime_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days l1', - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Lifetime energy consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.231', + 'state': '0.003322', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -21520,7 +25885,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21530,45 +25895,48 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days l2', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production_phase', - 'unique_id': '1234_seven_days_production_l2', - 'unit_of_measurement': , + 'translation_key': 'lifetime_production', + 'unique_id': '1234_lifetime_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days l2', - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Lifetime energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.231', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -21576,7 +25944,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21586,40 +25954,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days l3', + 'original_name': 'Lifetime energy production l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production_phase', - 'unique_id': '1234_seven_days_production_l3', - 'unit_of_measurement': , + 'translation_key': 'lifetime_production_phase', + 'unique_id': '1234_lifetime_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_last_seven_days_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days l3', - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Lifetime energy production l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.231', + 'state': '0.001232', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -21634,7 +26003,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21644,41 +26013,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today', + 'original_name': 'Lifetime energy production l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production', - 'unique_id': '1234_daily_production', - 'unit_of_measurement': , + 'translation_key': 'lifetime_production_phase', + 'unique_id': '1234_lifetime_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today', + 'friendly_name': 'Envoy 1234 Lifetime energy production l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '0.002232', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -21693,7 +26062,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21703,41 +26072,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today l1', + 'original_name': 'Lifetime energy production l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production_phase', - 'unique_id': '1234_daily_production_l1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_production_phase', + 'unique_id': '1234_lifetime_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today l1', + 'friendly_name': 'Envoy 1234 Lifetime energy production l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.233', + 'state': '0.003232', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -21752,7 +26121,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21762,41 +26131,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today l2', + 'original_name': 'Lifetime net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production_phase', - 'unique_id': '1234_daily_production_l2', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption', + 'unique_id': '1234_lifetime_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today l2', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.233', + 'state': '0.021234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -21811,7 +26180,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21821,47 +26190,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today l3', + 'original_name': 'Lifetime net energy consumption l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production_phase', - 'unique_id': '1234_daily_production_l3', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_energy_production_today_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today l3', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.233', + 'state': '0.212341', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -21870,7 +26239,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21880,44 +26249,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT', + 'original_name': 'Lifetime net energy consumption l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency', - 'unique_id': '1234_frequency', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '0.212342', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -21926,7 +26298,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21936,44 +26308,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l1', + 'original_name': 'Lifetime net energy consumption l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_consumption_phase', + 'unique_id': '1234_lifetime_net_consumption_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '0.212343', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -21982,7 +26357,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -21992,44 +26367,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l2', + 'original_name': 'Lifetime net energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l2', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production', + 'unique_id': '1234_lifetime_net_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '0.022345', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -22038,7 +26416,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22048,44 +26426,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency net consumption CT l3', + 'original_name': 'Lifetime net energy production l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_frequency_phase', - 'unique_id': '1234_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_net_consumption_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency net consumption CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.2', + 'state': '0.223451', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -22094,7 +26475,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22104,44 +26485,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT', + 'original_name': 'Lifetime net energy production l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency', - 'unique_id': '1234_production_ct_frequency', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l2-state] StateSnapshot({ - 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT', - 'state_class': , - 'unit_of_measurement': , + 'attributes': ReadOnlyDict({ + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '0.223452', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -22150,7 +26534,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22160,53 +26544,54 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT l1', + 'original_name': 'Lifetime net energy production l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_net_production_phase', + 'unique_id': '1234_lifetime_net_production_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '0.223453', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22215,54 +26600,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Frequency production CT l2', + 'original_name': 'Meter status flags active net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_status_flags', + 'unique_id': '1234_net_consumption_ct_status_flags', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '0', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22271,54 +26648,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Frequency production CT l3', + 'original_name': 'Meter status flags active net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency_phase', - 'unique_id': '1234_production_ct_frequency_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_frequency_production_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT l3', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': '0', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22327,57 +26696,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption', + 'original_name': 'Meter status flags active net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption', - 'unique_id': '1234_lifetime_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4.321', + 'state': '0', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22386,57 +26744,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption l1', + 'original_name': 'Meter status flags active net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption_phase', - 'unique_id': '1234_lifetime_balanced_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_status_flags_phase', + 'unique_id': '1234_net_consumption_ct_status_flags_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.321', + 'state': '0', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22445,57 +26792,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption l2', + 'original_name': 'Meter status flags active production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption_phase', - 'unique_id': '1234_lifetime_balanced_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags', + 'unique_id': '1234_production_ct_status_flags', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.321', + 'state': '2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22504,57 +26840,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption l3', + 'original_name': 'Meter status flags active production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption_phase', - 'unique_id': '1234_lifetime_balanced_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] StateSnapshot({ - 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'attributes': ReadOnlyDict({ + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '3.321', + 'state': '1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22563,57 +26888,46 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Lifetime energy consumption', + 'original_name': 'Meter status flags active production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption', - 'unique_id': '1234_lifetime_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': '1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22622,48 +26936,43 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Lifetime energy consumption l1', + 'original_name': 'Meter status flags active production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption_phase', - 'unique_id': '1234_lifetime_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags_phase', + 'unique_id': '1234_production_ct_status_flags_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001322', + 'state': '0', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -22671,8 +26980,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22681,48 +26990,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption l2', + 'original_name': 'Metering status net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption_phase', - 'unique_id': '1234_lifetime_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status', + 'unique_id': '1234_net_consumption_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.002322', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -22730,8 +27040,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22740,48 +27050,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy consumption l3', + 'original_name': 'Metering status net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_consumption_phase', - 'unique_id': '1234_lifetime_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_consumption_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.003322', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -22789,8 +27100,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22799,48 +27110,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production', + 'original_name': 'Metering status net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production', - 'unique_id': '1234_lifetime_production', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -22848,8 +27160,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22858,48 +27170,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production l1', + 'original_name': 'Metering status net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production_phase', - 'unique_id': '1234_lifetime_production_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_metering_status_phase', + 'unique_id': '1234_net_consumption_ct_metering_status_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001232', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -22907,8 +27220,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22917,48 +27230,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production l2', + 'original_name': 'Metering status production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production_phase', - 'unique_id': '1234_lifetime_production_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status', + 'unique_id': '1234_production_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.002232', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -22966,8 +27280,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22976,48 +27290,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production l3', + 'original_name': 'Metering status production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production_phase', - 'unique_id': '1234_lifetime_production_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_energy_production_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l1', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.003232', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -23025,8 +27340,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23035,48 +27350,49 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption', + 'original_name': 'Metering status production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption', - 'unique_id': '1234_lifetime_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l2', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l2', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.021234', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -23084,8 +27400,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23094,48 +27410,45 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l1', + 'original_name': 'Metering status production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status_phase', + 'unique_id': '1234_production_ct_metering_status_l3', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT l3', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l1', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212341', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23144,7 +27457,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23157,44 +27470,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l2', + 'original_name': 'Net consumption CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current', + 'unique_id': '1234_net_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l2', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212342', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23203,7 +27516,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23216,44 +27529,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy consumption l3', + 'original_name': 'Net consumption CT current l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_consumption_phase', - 'unique_id': '1234_lifetime_net_consumption_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_consumption_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy consumption l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_consumption_l3', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.212343', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23262,7 +27575,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23275,44 +27588,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production', + 'original_name': 'Net consumption CT current l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production', - 'unique_id': '1234_lifetime_net_production', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.022345', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23321,7 +27634,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23334,44 +27647,44 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l1', + 'original_name': 'Net consumption CT current l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l1', - 'unit_of_measurement': , + 'translation_key': 'net_ct_current_phase', + 'unique_id': '1234_net_ct_current_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Net consumption CT current l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l1', + 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223451', + 'state': '0.3', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23380,7 +27693,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23390,47 +27703,43 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l2', + 'original_name': 'Power factor net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l2', - 'unit_of_measurement': , + 'translation_key': 'net_ct_powerfactor', + 'unique_id': '1234_net_ct_powerfactor', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l2', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223452', + 'state': '0.21', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23439,7 +27748,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23449,54 +27758,52 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime net energy production l3', + 'original_name': 'Power factor net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_net_production_phase', - 'unique_id': '1234_lifetime_net_production_l3', - 'unit_of_measurement': , + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l1', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_lifetime_net_energy_production_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime net energy production l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_net_energy_production_l3', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.223453', + 'state': '0.22', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23505,46 +27812,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT', + 'original_name': 'Power factor net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags', - 'unique_id': '1234_net_consumption_ct_status_flags', + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l2', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '0.23', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23553,46 +27867,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l1', + 'original_name': 'Power factor net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l1', + 'translation_key': 'net_ct_powerfactor_phase', + 'unique_id': '1234_net_ct_powerfactor_l3', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l1', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '0.24', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23601,46 +27922,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l2', + 'original_name': 'Power factor production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l2', + 'translation_key': 'production_ct_powerfactor', + 'unique_id': '1234_production_ct_powerfactor', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l2', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '0.11', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23649,46 +27977,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active net consumption CT l3', + 'original_name': 'Power factor production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_status_flags_phase', - 'unique_id': '1234_net_consumption_ct_status_flags_l3', + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l1', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active net consumption CT l3', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l1', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '0.12', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23697,46 +28032,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT', + 'original_name': 'Power factor production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags', - 'unique_id': '1234_production_ct_status_flags', + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l2', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l2', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2', + 'state': '0.13', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23745,46 +28087,53 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l1', + 'original_name': 'Power factor production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l1', + 'translation_key': 'production_ct_powerfactor_phase', + 'unique_id': '1234_production_ct_powerfactor_l3', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l1', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT l3', + 'state_class': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '0.14', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23793,46 +28142,57 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l2', + 'original_name': 'Production CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l2', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_current', + 'unique_id': '1234_production_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l2', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23841,43 +28201,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT l3', + 'original_name': 'Production CT current l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags_phase', - 'unique_id': '1234_production_ct_status_flags_l3', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_meter_status_flags_active_production_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT l3', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23885,8 +28250,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23895,49 +28260,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT', + 'original_name': 'Production CT current l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status', - 'unique_id': '1234_net_consumption_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -23945,8 +28309,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -23955,49 +28319,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l1', + 'original_name': 'Production CT current l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_current_phase', + 'unique_id': '1234_production_ct_current_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24005,8 +28368,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24015,49 +28378,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l2', + 'original_name': 'Voltage net consumption CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_voltage', + 'unique_id': '1234_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct-state] StateSnapshot({ - 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l2', - 'options': list([ - , - , - , - ]), + 'attributes': ReadOnlyDict({ + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '112', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24065,8 +28427,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24075,49 +28437,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status net consumption CT l3', + 'original_name': 'Voltage net consumption CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_metering_status_phase', - 'unique_id': '1234_net_consumption_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_net_consumption_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status net consumption CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '112', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24125,8 +28486,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24135,49 +28496,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT', + 'original_name': 'Voltage net consumption CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status', - 'unique_id': '1234_production_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '112', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24185,8 +28545,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24195,49 +28555,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l1', + 'original_name': 'Voltage net consumption CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l1', - 'unit_of_measurement': None, + 'translation_key': 'net_ct_voltage_phase', + 'unique_id': '1234_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l1', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '112', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24245,8 +28604,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24255,49 +28614,48 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l2', + 'original_name': 'Voltage production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l2', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_voltage', + 'unique_id': '1234_production_ct_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l2', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '111', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24305,8 +28663,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_category': None, + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24315,39 +28673,42 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 1, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT l3', + 'original_name': 'Voltage production CT l1', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status_phase', - 'unique_id': '1234_production_ct_metering_status_l3', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_metering_status_production_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT l3', - 'options': list([ - , - , - , - ]), + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l1', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': '111', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l2-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24362,7 +28723,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24372,41 +28733,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current', + 'original_name': 'Voltage production CT l2', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current', - 'unique_id': '1234_net_ct_current', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l2', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l2-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l2', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '111', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l3-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24421,7 +28782,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24431,41 +28792,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l1', + 'original_name': 'Voltage production CT l3', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage_phase', + 'unique_id': '1234_production_ct_voltage_l3', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l3-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l1', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT l3', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l1', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '111', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24480,7 +28841,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.inverter_1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24490,41 +28851,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l2', + 'original_name': None, 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l2', + 'device_class': 'power', + 'friendly_name': 'Inverter 1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l2', + 'entity_id': 'sensor.inverter_1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': '1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_ac_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24539,7 +28897,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24551,39 +28909,36 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Net consumption CT current l3', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_current_phase', - 'unique_id': '1234_net_ct_current_l3', + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_net_consumption_ct_current_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_ac_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Net consumption CT current l3', + 'friendly_name': 'Inverter 1 AC current', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_net_consumption_ct_current_l3', + 'entity_id': 'sensor.inverter_1_ac_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.3', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_ac_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24598,7 +28953,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24608,37 +28963,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor', - 'unique_id': '1234_net_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_ac_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 AC voltage', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.21', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_dc_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24653,7 +29009,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24663,37 +29019,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l1', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_dc_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l1', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 DC current', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l1', + 'entity_id': 'sensor.inverter_1_dc_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.22', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_dc_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24708,7 +29065,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24718,43 +29075,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l2', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l2', - 'unit_of_measurement': None, + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_dc_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l2', + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 DC voltage', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l2', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.23', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24763,7 +29121,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24773,43 +29131,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor net consumption CT l3', + 'original_name': 'Energy produced since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_powerfactor_phase', - 'unique_id': '1234_net_ct_powerfactor_l3', - 'unit_of_measurement': None, + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_net_consumption_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor net consumption CT l3', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_net_consumption_ct_l3', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.24', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -24818,7 +29177,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24828,37 +29187,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT', + 'original_name': 'Energy produced today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor', - 'unique_id': '1234_production_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT', - 'state_class': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.11', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_frequency-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24873,7 +29233,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24883,37 +29243,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l1', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l1', - 'unit_of_measurement': None, + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_frequency-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l1', + 'device_class': 'frequency', + 'friendly_name': 'Inverter 1 Frequency', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l1', + 'entity_id': 'sensor.inverter_1_frequency', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.12', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_last_report_duration-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -24927,8 +29288,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_last_report_duration', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24941,41 +29302,40 @@ 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l2', + 'original_name': 'Last report duration', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l2', - 'unit_of_measurement': None, + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_last_report_duration-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l2', + 'device_class': 'duration', + 'friendly_name': 'Inverter 1 Last report duration', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l2', + 'entity_id': 'sensor.inverter_1_last_report_duration', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.13', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l3-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -24983,7 +29343,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_id': 'sensor.inverter_1_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -24992,44 +29352,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 2, - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT l3', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor_phase', - 'unique_id': '1234_production_ct_powerfactor_l3', + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_power_factor_production_ct_l3-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT l3', - 'state_class': , + 'device_class': 'timestamp', + 'friendly_name': 'Inverter 1 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct_l3', + 'entity_id': 'sensor.inverter_1_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.14', + 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_energy_produced-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -25038,7 +29394,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25048,41 +29404,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current', + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current', - 'unique_id': '1234_production_ct_current', - 'unit_of_measurement': , + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_energy_produced-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l1-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_maximum_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25096,8 +29452,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25107,41 +29463,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l1', + 'original_name': 'Lifetime maximum power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l1', - 'unit_of_measurement': , + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l1-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_maximum_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l1', + 'device_class': 'power', + 'friendly_name': 'Inverter 1 Lifetime maximum power', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l1', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l2-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25155,8 +29508,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25168,39 +29521,36 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l2', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l2', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l2-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l2', + 'device_class': 'temperature', + 'friendly_name': 'Inverter 1 Temperature', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l2', + 'entity_id': 'sensor.inverter_1_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l3-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_balanced_net_power_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25215,7 +29565,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25228,38 +29578,38 @@ 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current l3', + 'original_name': 'Balanced net power consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current_phase', - 'unique_id': '1234_production_ct_current_l3', - 'unit_of_measurement': , + 'translation_key': 'balanced_net_consumption', + 'unique_id': '1234_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_production_ct_current_l3-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_balanced_net_power_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current l3', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Balanced net power consumption', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current_l3', + 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '2.341', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_current_power_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25274,7 +29624,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25284,48 +29634,46 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT', + 'original_name': 'Current power production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage', - 'unique_id': '1234_voltage', - 'unit_of_measurement': , + 'translation_key': 'current_power_production', + 'unique_id': '1234_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_current_power_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT', + 'device_class': 'power', + 'friendly_name': 'Envoy 1234 Current power production', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct', + 'entity_id': 'sensor.envoy_1234_current_power_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l1-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_last_seven_days-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -25333,7 +29681,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25346,44 +29694,43 @@ 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l1', + 'original_name': 'Energy production last seven days', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'seven_days_production', + 'unique_id': '1234_seven_days_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l1-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_last_seven_days-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production last seven days', + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l1', + 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l2-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -25392,7 +29739,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25402,41 +29749,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l2', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'daily_production', + 'unique_id': '1234_daily_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l2-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l2', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Energy production today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l2', + 'entity_id': 'sensor.envoy_1234_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '1.234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l3-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_frequency_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25451,7 +29798,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25463,45 +29810,42 @@ 'sensor': dict({ 'suggested_display_precision': 1, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage net consumption CT l3', + 'original_name': 'Frequency production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'net_ct_voltage_phase', - 'unique_id': '1234_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_frequency', + 'unique_id': '1234_production_ct_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_net_consumption_ct_l3-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_frequency_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage net consumption CT l3', + 'device_class': 'frequency', + 'friendly_name': 'Envoy 1234 Frequency production CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_net_consumption_ct_l3', + 'entity_id': 'sensor.envoy_1234_frequency_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '112', + 'state': '50.1', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -25510,7 +29854,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25520,47 +29864,47 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT', + 'original_name': 'Lifetime balanced net energy consumption', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage', - 'unique_id': '1234_production_ct_voltage', - 'unit_of_measurement': , + 'translation_key': 'lifetime_balanced_net_consumption', + 'unique_id': '1234_lifetime_balanced_net_consumption', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '4.321', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l1-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -25569,7 +29913,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25579,56 +29923,54 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l1', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l1', - 'unit_of_measurement': , + 'translation_key': 'lifetime_production', + 'unique_id': '1234_lifetime_production', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l1-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l1', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Envoy 1234 Lifetime energy production', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l1', + 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '0.001234', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l2-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25637,48 +29979,43 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': None, 'original_icon': None, - 'original_name': 'Voltage production CT l2', + 'original_name': 'Meter status flags active production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l2', - 'unit_of_measurement': , + 'translation_key': 'production_ct_status_flags', + 'unique_id': '1234_production_ct_status_flags', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l2-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l2', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Envoy 1234 Meter status flags active production CT', }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l2', + 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': '2', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l3-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_metering_status_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'options': list([ + , + , + , + ]), }), 'config_entry_id': , 'config_subentry_id': , @@ -25686,8 +30023,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_category': , + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25696,42 +30033,39 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT l3', + 'original_name': 'Metering status production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage_phase', - 'unique_id': '1234_production_ct_voltage_l3', - 'unit_of_measurement': , + 'translation_key': 'production_ct_metering_status', + 'unique_id': '1234_production_ct_metering_status', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.envoy_1234_voltage_production_ct_l3-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_metering_status_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT l3', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'enum', + 'friendly_name': 'Envoy 1234 Metering status production CT', + 'options': list([ + , + , + , + ]), }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct_l3', + 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': 'normal', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_power_factor_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25746,7 +30080,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25756,43 +30090,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 0, + 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': None, + 'original_name': 'Power factor production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', - 'unit_of_measurement': , + 'translation_key': 'production_ct_powerfactor', + 'unique_id': '1234_production_ct_powerfactor', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_power_factor_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Inverter 1', + 'device_class': 'power_factor', + 'friendly_name': 'Envoy 1234 Power factor production CT', 'state_class': , - 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1', + 'state': '0.11', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_last_reported-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_production_ct_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -25800,7 +30135,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25809,34 +30144,42 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Production CT current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', - 'unit_of_measurement': None, + 'translation_key': 'production_ct_current', + 'unique_id': '1234_production_ct_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_last_reported-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_production_ct_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Inverter 1 Last reported', + 'device_class': 'current', + 'friendly_name': 'Envoy 1234 Production CT current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.envoy_1234_production_ct_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1970-01-01T00:00:01+00:00', + 'state': '0.2', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_balanced_net_power_consumption-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_voltage_production_ct-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25851,7 +30194,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25861,41 +30204,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, + 'suggested_display_precision': 1, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Balanced net power consumption', + 'original_name': 'Voltage production CT', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'balanced_net_consumption', - 'unique_id': '1234_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'production_ct_voltage', + 'unique_id': '1234_production_ct_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_balanced_net_power_consumption-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_voltage_production_ct-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Balanced net power consumption', + 'device_class': 'voltage', + 'friendly_name': 'Envoy 1234 Voltage production CT', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_balanced_net_power_consumption', + 'entity_id': 'sensor.envoy_1234_voltage_production_ct', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2.341', + 'state': '111', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_current_power_production-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -25910,7 +30253,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.inverter_1', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25920,46 +30263,45 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 0, }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Current power production', + 'original_name': None, 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'current_power_production', - 'unique_id': '1234_production', - 'unit_of_measurement': , + 'translation_key': None, + 'unique_id': '1', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_current_power_production-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'power', - 'friendly_name': 'Envoy 1234 Current power production', + 'friendly_name': 'Inverter 1', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_current_power_production', + 'entity_id': 'sensor.inverter_1', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': '1', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_last_seven_days-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_ac_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -25967,7 +30309,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.inverter_1_ac_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -25977,46 +30319,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production last seven days', + 'original_name': 'AC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'seven_days_production', - 'unique_id': '1234_seven_days_production', - 'unit_of_measurement': , + 'translation_key': 'ac_current', + 'unique_id': '1_ac_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_last_seven_days-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_ac_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production last seven days', - 'unit_of_measurement': , + 'device_class': 'current', + 'friendly_name': 'Inverter 1 AC current', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_last_seven_days', + 'entity_id': 'sensor.inverter_1_ac_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_today-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_ac_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -26025,7 +30365,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26035,41 +30375,38 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 2, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy production today', + 'original_name': 'AC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'daily_production', - 'unique_id': '1234_daily_production', - 'unit_of_measurement': , + 'translation_key': 'ac_voltage', + 'unique_id': '1_ac_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_energy_production_today-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_ac_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Energy production today', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 AC voltage', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_energy_production_today', + 'entity_id': 'sensor.inverter_1_ac_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1.234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_frequency_production_ct-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_dc_current-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -26084,7 +30421,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.inverter_1_dc_current', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26094,44 +30431,44 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 3, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Frequency production CT', + 'original_name': 'DC current', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_frequency', - 'unique_id': '1234_production_ct_frequency', - 'unit_of_measurement': , + 'translation_key': 'dc_current', + 'unique_id': '1_dc_current', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_frequency_production_ct-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_dc_current-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'frequency', - 'friendly_name': 'Envoy 1234 Frequency production CT', + 'device_class': 'current', + 'friendly_name': 'Inverter 1 DC current', 'state_class': , - 'unit_of_measurement': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_frequency_production_ct', + 'entity_id': 'sensor.inverter_1_dc_current', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '50.1', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_dc_voltage-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -26140,7 +30477,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26152,45 +30489,42 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime balanced net energy consumption', + 'original_name': 'DC voltage', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_balanced_net_consumption', - 'unique_id': '1234_lifetime_balanced_net_consumption', - 'unit_of_measurement': , + 'translation_key': 'dc_voltage', + 'unique_id': '1_dc_voltage', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_balanced_net_energy_consumption-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_dc_voltage-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime balanced net energy consumption', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'voltage', + 'friendly_name': 'Inverter 1 DC voltage', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_balanced_net_energy_consumption', + 'entity_id': 'sensor.inverter_1_dc_voltage', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '4.321', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_energy_production-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -26199,7 +30533,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26211,52 +30545,51 @@ 'sensor': dict({ 'suggested_display_precision': 3, }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy production', + 'original_name': 'Energy produced since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'lifetime_production', - 'unique_id': '1234_lifetime_production', - 'unit_of_measurement': , + 'translation_key': 'energy_produced', + 'unique_id': '1_energy_produced', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_lifetime_energy_production-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Envoy 1234 Lifetime energy production', - 'state_class': , - 'unit_of_measurement': , + 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_lifetime_energy_production', + 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.001234', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26265,43 +30598,45 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), }), - 'original_device_class': None, + 'original_device_class': , 'original_icon': None, - 'original_name': 'Meter status flags active production CT', + 'original_name': 'Energy produced today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_status_flags', - 'unique_id': '1234_production_ct_status_flags', - 'unit_of_measurement': None, + 'translation_key': 'energy_today', + 'unique_id': '1_energy_today', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_meter_status_flags_active_production_ct-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'friendly_name': 'Envoy 1234 Meter status flags active production CT', + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Energy produced today', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_meter_status_flags_active_production_ct', + 'entity_id': 'sensor.inverter_1_energy_produced_today', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '2', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_metering_status_production_ct-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_frequency-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'options': list([ - , - , - , - ]), + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -26309,8 +30644,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_category': None, + 'entity_id': 'sensor.inverter_1_frequency', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26319,39 +30654,39 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Metering status production CT', + 'original_name': 'Frequency', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_metering_status', - 'unique_id': '1234_production_ct_metering_status', - 'unit_of_measurement': None, + 'translation_key': None, + 'unique_id': '1_ac_frequency', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_metering_status_production_ct-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_frequency-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'enum', - 'friendly_name': 'Envoy 1234 Metering status production CT', - 'options': list([ - , - , - , - ]), + 'device_class': 'frequency', + 'friendly_name': 'Inverter 1 Frequency', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_metering_status_production_ct', + 'entity_id': 'sensor.inverter_1_frequency', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': 'normal', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_power_factor_production_ct-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_last_report_duration-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -26365,8 +30700,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_last_report_duration', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26379,41 +30714,40 @@ 'suggested_display_precision': 2, }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Power factor production CT', + 'original_name': 'Last report duration', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_powerfactor', - 'unique_id': '1234_production_ct_powerfactor', - 'unit_of_measurement': None, + 'translation_key': 'last_report_duration', + 'unique_id': '1_last_report_duration', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_power_factor_production_ct-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_last_report_duration-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'power_factor', - 'friendly_name': 'Envoy 1234 Power factor production CT', + 'device_class': 'duration', + 'friendly_name': 'Inverter 1 Last report duration', 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_power_factor_production_ct', + 'entity_id': 'sensor.inverter_1_last_report_duration', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.11', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_production_ct_current-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_last_reported-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': dict({ - 'state_class': , - }), + 'capabilities': None, 'config_entry_id': , 'config_subentry_id': , 'device_class': None, @@ -26421,7 +30755,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.inverter_1_last_reported', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26430,48 +30764,40 @@ }), 'name': None, 'options': dict({ - 'sensor': dict({ - 'suggested_display_precision': 3, - }), - 'sensor.private': dict({ - 'suggested_unit_of_measurement': , - }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Production CT current', + 'original_name': 'Last reported', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_current', - 'unique_id': '1234_production_ct_current', - 'unit_of_measurement': , + 'translation_key': 'last_reported', + 'unique_id': '1_last_reported', + 'unit_of_measurement': None, }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_production_ct_current-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_last_reported-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'current', - 'friendly_name': 'Envoy 1234 Production CT current', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'timestamp', + 'friendly_name': 'Inverter 1 Last reported', }), 'context': , - 'entity_id': 'sensor.envoy_1234_production_ct_current', + 'entity_id': 'sensor.inverter_1_last_reported', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0.2', + 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_voltage_production_ct-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_energy_produced-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, 'capabilities': dict({ - 'state_class': , + 'state_class': , }), 'config_entry_id': , 'config_subentry_id': , @@ -26480,7 +30806,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26490,41 +30816,41 @@ 'name': None, 'options': dict({ 'sensor': dict({ - 'suggested_display_precision': 1, + 'suggested_display_precision': 2, }), 'sensor.private': dict({ - 'suggested_unit_of_measurement': , + 'suggested_unit_of_measurement': , }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Voltage production CT', + 'original_name': 'Lifetime energy produced', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'production_ct_voltage', - 'unique_id': '1234_production_ct_voltage', - 'unit_of_measurement': , + 'translation_key': 'lifetime_energy', + 'unique_id': '1_lifetime_energy', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.envoy_1234_voltage_production_ct-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_energy_produced-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'voltage', - 'friendly_name': 'Envoy 1234 Voltage production CT', - 'state_class': , - 'unit_of_measurement': , + 'device_class': 'energy', + 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.envoy_1234_voltage_production_ct', + 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '111', + 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_maximum_power-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -26538,8 +30864,8 @@ 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.inverter_1', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26554,46 +30880,48 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': None, + 'original_name': 'Lifetime maximum power', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': None, - 'unique_id': '1', + 'translation_key': 'max_reported', + 'unique_id': '1_max_reported', 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_maximum_power-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'power', - 'friendly_name': 'Inverter 1', + 'friendly_name': 'Inverter 1 Lifetime maximum power', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1', + 'entity_id': 'sensor.inverter_1_lifetime_maximum_power', 'last_changed': , 'last_reported': , 'last_updated': , 'state': '1', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_last_reported-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_temperature-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), 'area_id': None, - 'capabilities': None, + 'capabilities': dict({ + 'state_class': , + }), 'config_entry_id': , 'config_subentry_id': , 'device_class': None, 'device_id': , 'disabled_by': None, 'domain': 'sensor', - 'entity_category': None, - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_category': , + 'entity_id': 'sensor.inverter_1_temperature', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -26602,30 +30930,35 @@ }), 'name': None, 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 3, + }), }), - 'original_device_class': , + 'original_device_class': , 'original_icon': None, - 'original_name': 'Last reported', + 'original_name': 'Temperature', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, 'supported_features': 0, - 'translation_key': 'last_reported', - 'unique_id': '1_last_reported', - 'unit_of_measurement': None, + 'translation_key': None, + 'unique_id': '1_temperature', + 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_last_reported-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_temperature-state] StateSnapshot({ 'attributes': ReadOnlyDict({ - 'device_class': 'timestamp', - 'friendly_name': 'Inverter 1 Last reported', + 'device_class': 'temperature', + 'friendly_name': 'Inverter 1 Temperature', + 'state_class': , + 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_last_reported', + 'entity_id': 'sensor.inverter_1_temperature', 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '1970-01-01T00:00:01+00:00', + 'state': 'unknown', }) # --- diff --git a/tests/components/enphase_envoy/test_init.py b/tests/components/enphase_envoy/test_init.py index 560d0719424a92..a738b31c1830cf 100644 --- a/tests/components/enphase_envoy/test_init.py +++ b/tests/components/enphase_envoy/test_init.py @@ -54,7 +54,7 @@ async def test_with_pre_v7_firmware( await setup_integration(hass, config_entry) assert (entity_state := hass.states.get("sensor.inverter_1")) - assert entity_state.state == "1" + assert entity_state.state == "116" @pytest.mark.freeze_time("2024-07-23 00:00:00+00:00") @@ -85,7 +85,7 @@ async def test_token_in_config_file( await setup_integration(hass, entry) assert (entity_state := hass.states.get("sensor.inverter_1")) - assert entity_state.state == "1" + assert entity_state.state == "116" @respx.mock @@ -128,7 +128,7 @@ async def test_expired_token_in_config( await setup_integration(hass, entry) assert (entity_state := hass.states.get("sensor.inverter_1")) - assert entity_state.state == "1" + assert entity_state.state == "116" async def test_coordinator_update_error( @@ -226,7 +226,7 @@ async def test_coordinator_token_refresh_error( await setup_integration(hass, entry) assert (entity_state := hass.states.get("sensor.inverter_1")) - assert entity_state.state == "1" + assert entity_state.state == "116" async def test_config_no_unique_id( diff --git a/tests/components/enphase_envoy/test_sensor.py b/tests/components/enphase_envoy/test_sensor.py index 89f28c74514e90..70bf8c990077ad 100644 --- a/tests/components/enphase_envoy/test_sensor.py +++ b/tests/components/enphase_envoy/test_sensor.py @@ -772,6 +772,70 @@ async def test_sensor_inverter_data( ) == dt_util.utc_from_timestamp(inverter.last_report_date) +@pytest.mark.parametrize( + ("mock_envoy"), + [ + "envoy", + ], + indirect=["mock_envoy"], +) +@pytest.mark.usefixtures("entity_registry_enabled_by_default") +async def test_sensor_inverter_detailed_data( + hass: HomeAssistant, + mock_envoy: AsyncMock, + config_entry: MockConfigEntry, +) -> None: + """Test enphase_envoy inverter detailed entities values.""" + with patch("homeassistant.components.enphase_envoy.PLATFORMS", [Platform.SENSOR]): + await setup_integration(hass, config_entry) + + entity_base = f"{Platform.SENSOR}.inverter" + + for sn, inverter in mock_envoy.data.inverters.items(): + assert (dc_voltage := hass.states.get(f"{entity_base}_{sn}_dc_voltage")) + assert float(dc_voltage.state) == (inverter.dc_voltage) + assert (dc_current := hass.states.get(f"{entity_base}_{sn}_dc_current")) + assert float(dc_current.state) == (inverter.dc_current) + assert (ac_voltage := hass.states.get(f"{entity_base}_{sn}_ac_voltage")) + assert float(ac_voltage.state) == (inverter.ac_voltage) + assert (ac_current := hass.states.get(f"{entity_base}_{sn}_ac_current")) + assert float(ac_current.state) == (inverter.ac_current) + assert (frequency := hass.states.get(f"{entity_base}_{sn}_frequency")) + assert float(frequency.state) == (inverter.ac_frequency) + assert (temperature := hass.states.get(f"{entity_base}_{sn}_temperature")) + assert int(temperature.state) == (inverter.temperature) + assert ( + lifetime_energy := hass.states.get( + f"{entity_base}_{sn}_lifetime_energy_produced" + ) + ) + assert float(lifetime_energy.state) == (inverter.lifetime_energy / 1000.0) + assert ( + energy_produced_today := hass.states.get( + f"{entity_base}_{sn}_energy_produced_today" + ) + ) + assert int(energy_produced_today.state) == (inverter.energy_today) + assert ( + last_report_duration := hass.states.get( + f"{entity_base}_{sn}_last_report_duration" + ) + ) + assert int(last_report_duration.state) == (inverter.last_report_duration) + assert ( + energy_produced := hass.states.get( + f"{entity_base}_{sn}_energy_produced_since_previous_report" + ) + ) + assert float(energy_produced.state) == (inverter.energy_produced) + assert ( + lifetime_maximum_power := hass.states.get( + f"{entity_base}_{sn}_lifetime_maximum_power" + ) + ) + assert int(lifetime_maximum_power.state) == (inverter.max_report_watts) + + @pytest.mark.parametrize( ("mock_envoy"), [ @@ -797,9 +861,23 @@ async def test_sensor_inverter_disabled_by_integration( INVERTER_BASE = f"{Platform.SENSOR}.inverter" assert all( - f"{INVERTER_BASE}_{sn}_last_reported" + f"{INVERTER_BASE}_{sn}_{key}" in integration_disabled_entities(entity_registry, config_entry) for sn in mock_envoy.data.inverters + for key in ( + "dc_voltage", + "dc_current", + "ac_voltage", + "ac_current", + "frequency", + "temperature", + "lifetime_energy_produced", + "energy_produced_today", + "last_report_duration", + "energy_produced_since_previous_report", + "last_reported", + "lifetime_maximum_power", + ) ) From 512449a76d423e7093c4292170a154ed0c716786 Mon Sep 17 00:00:00 2001 From: Joost Lekkerkerker Date: Mon, 23 Jun 2025 21:01:01 +0200 Subject: [PATCH 21/30] Add Bluetooth connection to LaMetric (#147342) --- homeassistant/components/lametric/entity.py | 10 +++++++--- tests/components/lametric/fixtures/device.json | 2 +- .../lametric/snapshots/test_diagnostics.ambr | 2 +- tests/components/lametric/test_button.py | 12 ++++++++---- tests/components/lametric/test_number.py | 10 ++++++++-- tests/components/lametric/test_select.py | 5 ++++- tests/components/lametric/test_sensor.py | 5 ++++- tests/components/lametric/test_switch.py | 5 ++++- 8 files changed, 37 insertions(+), 14 deletions(-) diff --git a/homeassistant/components/lametric/entity.py b/homeassistant/components/lametric/entity.py index 4764974b5e0a59..f0c0d14e0e4584 100644 --- a/homeassistant/components/lametric/entity.py +++ b/homeassistant/components/lametric/entity.py @@ -3,6 +3,7 @@ from __future__ import annotations from homeassistant.helpers.device_registry import ( + CONNECTION_BLUETOOTH, CONNECTION_NETWORK_MAC, DeviceInfo, format_mac, @@ -21,10 +22,13 @@ class LaMetricEntity(CoordinatorEntity[LaMetricDataUpdateCoordinator]): def __init__(self, coordinator: LaMetricDataUpdateCoordinator) -> None: """Initialize the LaMetric entity.""" super().__init__(coordinator=coordinator) + connections = {(CONNECTION_NETWORK_MAC, format_mac(coordinator.data.wifi.mac))} + if coordinator.data.bluetooth is not None: + connections.add( + (CONNECTION_BLUETOOTH, format_mac(coordinator.data.bluetooth.address)) + ) self._attr_device_info = DeviceInfo( - connections={ - (CONNECTION_NETWORK_MAC, format_mac(coordinator.data.wifi.mac)) - }, + connections=connections, identifiers={(DOMAIN, coordinator.data.serial_number)}, manufacturer="LaMetric Inc.", model_id=coordinator.data.model, diff --git a/tests/components/lametric/fixtures/device.json b/tests/components/lametric/fixtures/device.json index a184d9f0aa1f61..bf2580a0c5df9e 100644 --- a/tests/components/lametric/fixtures/device.json +++ b/tests/components/lametric/fixtures/device.json @@ -12,7 +12,7 @@ }, "bluetooth": { "active": false, - "address": "AA:BB:CC:DD:EE:FF", + "address": "AA:BB:CC:DD:EE:EE", "available": true, "discoverable": true, "low_energy": { diff --git a/tests/components/lametric/snapshots/test_diagnostics.ambr b/tests/components/lametric/snapshots/test_diagnostics.ambr index bc16e318a739ad..ea9dfdde92fe0b 100644 --- a/tests/components/lametric/snapshots/test_diagnostics.ambr +++ b/tests/components/lametric/snapshots/test_diagnostics.ambr @@ -15,7 +15,7 @@ }), 'bluetooth': dict({ 'active': False, - 'address': 'AA:BB:CC:DD:EE:FF', + 'address': 'AA:BB:CC:DD:EE:EE', 'available': True, 'discoverable': True, 'name': '**REDACTED**', diff --git a/tests/components/lametric/test_button.py b/tests/components/lametric/test_button.py index cf8d76ca5f3f69..e42e3248a73ff7 100644 --- a/tests/components/lametric/test_button.py +++ b/tests/components/lametric/test_button.py @@ -44,7 +44,8 @@ async def test_button_app_next( assert device_entry assert device_entry.configuration_url == "https://127.0.0.1/" assert device_entry.connections == { - (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff") + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), } assert device_entry.entry_type is None assert device_entry.identifiers == {(DOMAIN, "SA110405124500W00BS9")} @@ -91,7 +92,8 @@ async def test_button_app_previous( assert device_entry assert device_entry.configuration_url == "https://127.0.0.1/" assert device_entry.connections == { - (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff") + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), } assert device_entry.entry_type is None assert device_entry.identifiers == {(DOMAIN, "SA110405124500W00BS9")} @@ -139,7 +141,8 @@ async def test_button_dismiss_current_notification( assert device_entry assert device_entry.configuration_url == "https://127.0.0.1/" assert device_entry.connections == { - (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff") + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), } assert device_entry.entry_type is None assert device_entry.identifiers == {(DOMAIN, "SA110405124500W00BS9")} @@ -187,7 +190,8 @@ async def test_button_dismiss_all_notifications( assert device_entry assert device_entry.configuration_url == "https://127.0.0.1/" assert device_entry.connections == { - (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff") + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), } assert device_entry.entry_type is None assert device_entry.identifiers == {(DOMAIN, "SA110405124500W00BS9")} diff --git a/tests/components/lametric/test_number.py b/tests/components/lametric/test_number.py index f34cf04aed9afb..dea693e86aa48f 100644 --- a/tests/components/lametric/test_number.py +++ b/tests/components/lametric/test_number.py @@ -56,7 +56,10 @@ async def test_brightness( device = device_registry.async_get(entry.device_id) assert device assert device.configuration_url == "https://127.0.0.1/" - assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff")} + assert device.connections == { + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), + } assert device.entry_type is None assert device.hw_version is None assert device.identifiers == {(DOMAIN, "SA110405124500W00BS9")} @@ -105,7 +108,10 @@ async def test_volume( device = device_registry.async_get(entry.device_id) assert device assert device.configuration_url == "https://127.0.0.1/" - assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff")} + assert device.connections == { + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), + } assert device.entry_type is None assert device.hw_version is None assert device.identifiers == {(DOMAIN, "SA110405124500W00BS9")} diff --git a/tests/components/lametric/test_select.py b/tests/components/lametric/test_select.py index 177092f061ef08..e7a2ad5267023c 100644 --- a/tests/components/lametric/test_select.py +++ b/tests/components/lametric/test_select.py @@ -49,7 +49,10 @@ async def test_brightness_mode( device = device_registry.async_get(entry.device_id) assert device assert device.configuration_url == "https://127.0.0.1/" - assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff")} + assert device.connections == { + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), + } assert device.entry_type is None assert device.hw_version is None assert device.identifiers == {(DOMAIN, "SA110405124500W00BS9")} diff --git a/tests/components/lametric/test_sensor.py b/tests/components/lametric/test_sensor.py index a0719edfc9d9d0..9915b31d28301e 100644 --- a/tests/components/lametric/test_sensor.py +++ b/tests/components/lametric/test_sensor.py @@ -42,7 +42,10 @@ async def test_wifi_signal( device = device_registry.async_get(entry.device_id) assert device assert device.configuration_url == "https://127.0.0.1/" - assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff")} + assert device.connections == { + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), + } assert device.entry_type is None assert device.hw_version is None assert device.identifiers == {(DOMAIN, "SA110405124500W00BS9")} diff --git a/tests/components/lametric/test_switch.py b/tests/components/lametric/test_switch.py index 155a315881fdd2..252ced706d3ec3 100644 --- a/tests/components/lametric/test_switch.py +++ b/tests/components/lametric/test_switch.py @@ -51,7 +51,10 @@ async def test_bluetooth( device = device_registry.async_get(entry.device_id) assert device assert device.configuration_url == "https://127.0.0.1/" - assert device.connections == {(dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff")} + assert device.connections == { + (dr.CONNECTION_NETWORK_MAC, "aa:bb:cc:dd:ee:ff"), + (dr.CONNECTION_BLUETOOTH, "aa:bb:cc:dd:ee:ee"), + } assert device.entry_type is None assert device.hw_version is None assert device.identifiers == {(DOMAIN, "SA110405124500W00BS9")} From c29879274a47a0b712bd11eb6059844bf35cdde9 Mon Sep 17 00:00:00 2001 From: Erik Montnemery Date: Mon, 23 Jun 2025 21:18:56 +0200 Subject: [PATCH 22/30] Refactor DeviceAutomationConditionProtocol (#147377) --- .../components/device_automation/condition.py | 22 +++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/homeassistant/components/device_automation/condition.py b/homeassistant/components/device_automation/condition.py index 13454d416a0500..92901f8e857a59 100644 --- a/homeassistant/components/device_automation/condition.py +++ b/homeassistant/components/device_automation/condition.py @@ -9,7 +9,10 @@ from homeassistant.const import CONF_DOMAIN from homeassistant.core import HomeAssistant from homeassistant.helpers import config_validation as cv -from homeassistant.helpers.condition import ConditionProtocol, trace_condition_function +from homeassistant.helpers.condition import ( + ConditionCheckerType, + trace_condition_function, +) from homeassistant.helpers.typing import ConfigType from . import DeviceAutomationType, async_get_device_automation_platform @@ -19,13 +22,24 @@ from homeassistant.helpers import condition -class DeviceAutomationConditionProtocol(ConditionProtocol, Protocol): +class DeviceAutomationConditionProtocol(Protocol): """Define the format of device_condition modules. - Each module must define either CONDITION_SCHEMA or async_validate_condition_config - from ConditionProtocol. + Each module must define either CONDITION_SCHEMA or async_validate_condition_config. """ + CONDITION_SCHEMA: vol.Schema + + async def async_validate_condition_config( + self, hass: HomeAssistant, config: ConfigType + ) -> ConfigType: + """Validate config.""" + + def async_condition_from_config( + self, hass: HomeAssistant, config: ConfigType + ) -> ConditionCheckerType: + """Evaluate state based on configuration.""" + async def async_get_condition_capabilities( self, hass: HomeAssistant, config: ConfigType ) -> dict[str, vol.Schema]: From b4fe6f3843aea749c842b0dfed0d69e34d645f68 Mon Sep 17 00:00:00 2001 From: Petro31 <35082313+Petro31@users.noreply.github.com> Date: Mon, 23 Jun 2025 15:20:55 -0400 Subject: [PATCH 23/30] Add trigger based fan entities to template integration (#145497) * Add trigger based fan entities to template integration * more changes * add tests * update doc strings --------- Co-authored-by: Erik Montnemery --- homeassistant/components/template/config.py | 1 - homeassistant/components/template/fan.py | 85 +++- tests/components/template/test_fan.py | 419 ++++++++++++++------ 3 files changed, 384 insertions(+), 121 deletions(-) diff --git a/homeassistant/components/template/config.py b/homeassistant/components/template/config.py index a5aa9a3bd87dfd..86769a0d22a735 100644 --- a/homeassistant/components/template/config.py +++ b/homeassistant/components/template/config.py @@ -158,7 +158,6 @@ def _backward_compat_schema(value: Any | None) -> Any: ), ensure_domains_do_not_have_trigger_or_action( DOMAIN_BUTTON, - DOMAIN_FAN, ), ) diff --git a/homeassistant/components/template/fan.py b/homeassistant/components/template/fan.py index 4837ded9029dcf..f7b0b57cf27fb9 100644 --- a/homeassistant/components/template/fan.py +++ b/homeassistant/components/template/fan.py @@ -15,6 +15,7 @@ ATTR_PRESET_MODE, DIRECTION_FORWARD, DIRECTION_REVERSE, + DOMAIN as FAN_DOMAIN, ENTITY_ID_FORMAT, FanEntity, FanEntityFeature, @@ -38,6 +39,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType from .const import CONF_OBJECT_ID, DOMAIN +from .coordinator import TriggerUpdateCoordinator from .entity import AbstractTemplateEntity from .template_entity import ( LEGACY_FIELDS as TEMPLATE_ENTITY_LEGACY_FIELDS, @@ -46,6 +48,7 @@ make_template_entity_common_modern_schema, rewrite_common_legacy_to_modern_conf, ) +from .trigger_entity import TriggerEntity _LOGGER = logging.getLogger(__name__) @@ -193,6 +196,13 @@ async def async_setup_platform( ) return + if "coordinator" in discovery_info: + async_add_entities( + TriggerFanEntity(hass, discovery_info["coordinator"], config) + for config in discovery_info["entities"] + ) + return + _async_create_template_tracking_entities( async_add_entities, hass, @@ -228,7 +238,11 @@ def __init__(self, config: dict[str, Any]) -> None: # pylint: disable=super-ini self._preset_modes: list[str] | None = config.get(CONF_PRESET_MODES) self._attr_assumed_state = self._template is None - def _register_scripts( + self._attr_supported_features |= ( + FanEntityFeature.TURN_OFF | FanEntityFeature.TURN_ON + ) + + def _iterate_scripts( self, config: dict[str, Any] ) -> Generator[tuple[str, Sequence[dict[str, Any]], FanEntityFeature | int]]: for action_id, supported_feature in ( @@ -492,10 +506,7 @@ def __init__( if TYPE_CHECKING: assert name is not None - self._attr_supported_features |= ( - FanEntityFeature.TURN_OFF | FanEntityFeature.TURN_ON - ) - for action_id, action_config, supported_feature in self._register_scripts( + for action_id, action_config, supported_feature in self._iterate_scripts( config ): self.add_script(action_id, action_config, name, DOMAIN) @@ -551,3 +562,67 @@ def _async_setup_templates(self) -> None: none_on_template_error=True, ) super()._async_setup_templates() + + +class TriggerFanEntity(TriggerEntity, AbstractTemplateFan): + """Fan entity based on trigger data.""" + + domain = FAN_DOMAIN + + def __init__( + self, + hass: HomeAssistant, + coordinator: TriggerUpdateCoordinator, + config: ConfigType, + ) -> None: + """Initialize the entity.""" + TriggerEntity.__init__(self, hass, coordinator, config) + AbstractTemplateFan.__init__(self, config) + + self._attr_name = name = self._rendered.get(CONF_NAME, DEFAULT_NAME) + + for action_id, action_config, supported_feature in self._iterate_scripts( + config + ): + self.add_script(action_id, action_config, name, DOMAIN) + self._attr_supported_features |= supported_feature + + for key in ( + CONF_STATE, + CONF_PRESET_MODE, + CONF_PERCENTAGE, + CONF_OSCILLATING, + CONF_DIRECTION, + ): + if isinstance(config.get(key), template.Template): + self._to_render_simple.append(key) + self._parse_result.add(key) + + @callback + def _handle_coordinator_update(self) -> None: + """Handle update of the data.""" + self._process_data() + + if not self.available: + self.async_write_ha_state() + return + + write_ha_state = False + for key, updater in ( + (CONF_STATE, self._handle_state), + (CONF_PRESET_MODE, self._update_preset_mode), + (CONF_PERCENTAGE, self._update_percentage), + (CONF_OSCILLATING, self._update_oscillating), + (CONF_DIRECTION, self._update_direction), + ): + if (rendered := self._rendered.get(key)) is not None: + updater(rendered) + write_ha_state = True + + if len(self._rendered) > 0: + # In case any non optimistic template + write_ha_state = True + + if write_ha_state: + self.async_set_context(self.coordinator.data["context"]) + self.async_write_ha_state() diff --git a/tests/components/template/test_fan.py b/tests/components/template/test_fan.py index a061ce86256fce..708ad6bdecda0e 100644 --- a/tests/components/template/test_fan.py +++ b/tests/components/template/test_fan.py @@ -28,11 +28,30 @@ TEST_OBJECT_ID = "test_fan" TEST_ENTITY_ID = f"fan.{TEST_OBJECT_ID}" + # Represent for fan's state _STATE_INPUT_BOOLEAN = "input_boolean.state" -# Represent for fan's state +# Represent for fan's percent +_STATE_TEST_SENSOR = "sensor.test_sensor" +# Represent for fan's availability _STATE_AVAILABILITY_BOOLEAN = "availability_boolean.state" +TEST_STATE_TRIGGER = { + "trigger": { + "trigger": "state", + "entity_id": [ + TEST_ENTITY_ID, + _STATE_INPUT_BOOLEAN, + _STATE_AVAILABILITY_BOOLEAN, + _STATE_TEST_SENSOR, + ], + }, + "variables": {"triggering_entity": "{{ trigger.entity_id }}"}, + "action": [ + {"event": "action_event", "event_data": {"what": "{{ triggering_entity }}"}} + ], +} + OPTIMISTIC_ON_OFF_ACTIONS = { "turn_on": { "service": "test.automation", @@ -177,61 +196,22 @@ async def async_setup_modern_format( await hass.async_block_till_done() -async def async_setup_legacy_named_fan( - hass: HomeAssistant, count: int, fan_config: dict[str, Any] -): - """Do setup of a named fan via legacy format.""" - await async_setup_legacy_format(hass, count, {TEST_OBJECT_ID: fan_config}) - - -async def async_setup_modern_named_fan( +async def async_setup_trigger_format( hass: HomeAssistant, count: int, fan_config: dict[str, Any] -): - """Do setup of a named fan via legacy format.""" - await async_setup_modern_format(hass, count, {"name": TEST_OBJECT_ID, **fan_config}) - - -async def async_setup_legacy_format_with_attribute( - hass: HomeAssistant, - count: int, - attribute: str, - attribute_template: str, - extra_config: dict, ) -> None: - """Do setup of a legacy fan that has a single templated attribute.""" - extra = {attribute: attribute_template} if attribute and attribute_template else {} - await async_setup_legacy_format( - hass, - count, - { - TEST_OBJECT_ID: { - **extra_config, - "value_template": "{{ 1 == 1 }}", - **extra, - } - }, - ) + """Do setup of fan integration via trigger format.""" + config = {"template": {"fan": fan_config, **TEST_STATE_TRIGGER}} + with assert_setup_component(count, template.DOMAIN): + assert await async_setup_component( + hass, + template.DOMAIN, + config, + ) -async def async_setup_modern_format_with_attribute( - hass: HomeAssistant, - count: int, - attribute: str, - attribute_template: str, - extra_config: dict, -) -> None: - """Do setup of a modern fan that has a single templated attribute.""" - extra = {attribute: attribute_template} if attribute and attribute_template else {} - await async_setup_modern_format( - hass, - count, - { - "name": TEST_OBJECT_ID, - **extra_config, - "state": "{{ 1 == 1 }}", - **extra, - }, - ) + await hass.async_block_till_done() + await hass.async_start() + await hass.async_block_till_done() @pytest.fixture @@ -246,6 +226,8 @@ async def setup_fan( await async_setup_legacy_format(hass, count, fan_config) elif style == ConfigurationStyle.MODERN: await async_setup_modern_format(hass, count, fan_config) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format(hass, count, fan_config) @pytest.fixture @@ -257,9 +239,15 @@ async def setup_named_fan( ) -> None: """Do setup of fan integration.""" if style == ConfigurationStyle.LEGACY: - await async_setup_legacy_named_fan(hass, count, fan_config) + await async_setup_legacy_format(hass, count, {TEST_OBJECT_ID: fan_config}) elif style == ConfigurationStyle.MODERN: - await async_setup_modern_named_fan(hass, count, fan_config) + await async_setup_modern_format( + hass, count, {"name": TEST_OBJECT_ID, **fan_config} + ) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format( + hass, count, {"name": TEST_OBJECT_ID, **fan_config} + ) @pytest.fixture @@ -290,6 +278,15 @@ async def setup_state_fan( "state": state_template, }, ) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format( + hass, + count, + { + **NAMED_ON_OFF_ACTIONS, + "state": state_template, + }, + ) @pytest.fixture @@ -309,6 +306,10 @@ async def setup_test_fan_with_extra_config( await async_setup_modern_format( hass, count, {"name": TEST_OBJECT_ID, **fan_config, **extra_config} ) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format( + hass, count, {"name": TEST_OBJECT_ID, **fan_config, **extra_config} + ) @pytest.fixture @@ -320,12 +321,35 @@ async def setup_optimistic_fan_attribute( ) -> None: """Do setup of a non-optimistic fan with an optimistic attribute.""" if style == ConfigurationStyle.LEGACY: - await async_setup_legacy_format_with_attribute( - hass, count, "", "", extra_config + await async_setup_legacy_format( + hass, + count, + { + TEST_OBJECT_ID: { + **extra_config, + "value_template": "{{ 1 == 1 }}", + } + }, ) elif style == ConfigurationStyle.MODERN: - await async_setup_modern_format_with_attribute( - hass, count, "", "", extra_config + await async_setup_modern_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + **extra_config, + "state": "{{ 1 == 1 }}", + }, + ) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format( + hass, + count, + { + "name": TEST_OBJECT_ID, + **extra_config, + "state": "{{ 1 == 1 }}", + }, ) @@ -365,11 +389,23 @@ async def setup_single_attribute_state_fan( **extra_config, }, ) + elif style == ConfigurationStyle.TRIGGER: + await async_setup_trigger_format( + hass, + count, + { + **NAMED_ON_OFF_ACTIONS, + "state": state_template, + **extra, + **extra_config, + }, + ) @pytest.mark.parametrize(("count", "state_template"), [(1, "{{ 'on' }}")]) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_state_fan") async def test_missing_optional_config(hass: HomeAssistant) -> None: @@ -379,7 +415,8 @@ async def test_missing_optional_config(hass: HomeAssistant) -> None: @pytest.mark.parametrize("count", [0]) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( "fan_config", @@ -404,7 +441,8 @@ async def test_wrong_template_config(hass: HomeAssistant) -> None: ("count", "state_template"), [(1, "{{ is_state('input_boolean.state', 'on') }}")] ) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_state_fan") async def test_state_template(hass: HomeAssistant) -> None: @@ -433,7 +471,8 @@ async def test_state_template(hass: HomeAssistant) -> None: ], ) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_state_fan") async def test_state_template_states(hass: HomeAssistant, expected: str) -> None: @@ -442,29 +481,28 @@ async def test_state_template_states(hass: HomeAssistant, expected: str) -> None @pytest.mark.parametrize( - ("count", "state_template", "attribute_template", "extra_config"), + ("count", "state_template", "attribute_template", "extra_config", "attribute"), [ ( 1, "{{ 1 == 1}}", - "{% if states.input_boolean.state.state %}/local/switch.png{% endif %}", + "{% if is_state('sensor.test_sensor', 'on') %}/local/switch.png{% endif %}", {}, + "picture", ) ], ) @pytest.mark.parametrize( - ("style", "attribute"), - [ - (ConfigurationStyle.MODERN, "picture"), - ], + "style", + [ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_single_attribute_state_fan") async def test_picture_template(hass: HomeAssistant) -> None: """Test picture template.""" state = hass.states.get(TEST_ENTITY_ID) - assert state.attributes.get("entity_picture") in ("", None) + assert state.attributes.get("entity_picture") == "" - hass.states.async_set(_STATE_INPUT_BOOLEAN, STATE_ON) + hass.states.async_set(_STATE_TEST_SENSOR, STATE_ON) await hass.async_block_till_done() state = hass.states.get(TEST_ENTITY_ID) @@ -472,27 +510,26 @@ async def test_picture_template(hass: HomeAssistant) -> None: @pytest.mark.parametrize( - ("count", "state_template", "attribute_template", "extra_config"), + ("count", "state_template", "attribute_template", "extra_config", "attribute"), [ ( 1, "{{ 1 == 1}}", "{% if states.input_boolean.state.state %}mdi:eye{% endif %}", {}, + "icon", ) ], ) @pytest.mark.parametrize( - ("style", "attribute"), - [ - (ConfigurationStyle.MODERN, "icon"), - ], + "style", + [ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_single_attribute_state_fan") async def test_icon_template(hass: HomeAssistant) -> None: """Test icon template.""" state = hass.states.get(TEST_ENTITY_ID) - assert state.attributes.get("icon") in ("", None) + assert state.attributes.get("icon") == "" hass.states.async_set(_STATE_INPUT_BOOLEAN, STATE_ON) await hass.async_block_till_done() @@ -507,7 +544,7 @@ async def test_icon_template(hass: HomeAssistant) -> None: ( 1, "{{ 1 == 1 }}", - "{{ states('sensor.percentage') }}", + "{{ states('sensor.test_sensor') }}", PERCENTAGE_ACTION, ) ], @@ -517,6 +554,7 @@ async def test_icon_template(hass: HomeAssistant) -> None: [ (ConfigurationStyle.LEGACY, "percentage_template"), (ConfigurationStyle.MODERN, "percentage"), + (ConfigurationStyle.TRIGGER, "percentage"), ], ) @pytest.mark.parametrize( @@ -534,7 +572,7 @@ async def test_percentage_template( hass: HomeAssistant, percent: str, expected: int, calls: list[ServiceCall] ) -> None: """Test templates with fan percentages from other entities.""" - hass.states.async_set("sensor.percentage", percent) + hass.states.async_set(_STATE_TEST_SENSOR, percent) await hass.async_block_till_done() _verify(hass, STATE_ON, expected, None, None, None) @@ -545,7 +583,7 @@ async def test_percentage_template( ( 1, "{{ 1 == 1 }}", - "{{ states('sensor.preset_mode') }}", + "{{ states('sensor.test_sensor') }}", {"preset_modes": ["auto", "smart"], **PRESET_MODE_ACTION}, ) ], @@ -555,6 +593,7 @@ async def test_percentage_template( [ (ConfigurationStyle.LEGACY, "preset_mode_template"), (ConfigurationStyle.MODERN, "preset_mode"), + (ConfigurationStyle.TRIGGER, "preset_mode"), ], ) @pytest.mark.parametrize( @@ -571,7 +610,7 @@ async def test_preset_mode_template( hass: HomeAssistant, preset_mode: str, expected: int ) -> None: """Test preset_mode template.""" - hass.states.async_set("sensor.preset_mode", preset_mode) + hass.states.async_set(_STATE_TEST_SENSOR, preset_mode) await hass.async_block_till_done() _verify(hass, STATE_ON, None, None, None, expected) @@ -582,7 +621,7 @@ async def test_preset_mode_template( ( 1, "{{ 1 == 1 }}", - "{{ is_state('binary_sensor.oscillating', 'on') }}", + "{{ is_state('sensor.test_sensor', 'on') }}", OSCILLATE_ACTION, ) ], @@ -592,6 +631,7 @@ async def test_preset_mode_template( [ (ConfigurationStyle.LEGACY, "oscillating_template"), (ConfigurationStyle.MODERN, "oscillating"), + (ConfigurationStyle.TRIGGER, "oscillating"), ], ) @pytest.mark.parametrize( @@ -606,7 +646,7 @@ async def test_oscillating_template( hass: HomeAssistant, oscillating: str, expected: bool | None ) -> None: """Test oscillating template.""" - hass.states.async_set("binary_sensor.oscillating", oscillating) + hass.states.async_set(_STATE_TEST_SENSOR, oscillating) await hass.async_block_till_done() _verify(hass, STATE_ON, None, expected, None, None) @@ -617,7 +657,7 @@ async def test_oscillating_template( ( 1, "{{ 1 == 1 }}", - "{{ states('sensor.direction') }}", + "{{ states('sensor.test_sensor') }}", DIRECTION_ACTION, ) ], @@ -627,6 +667,7 @@ async def test_oscillating_template( [ (ConfigurationStyle.LEGACY, "direction_template"), (ConfigurationStyle.MODERN, "direction"), + (ConfigurationStyle.TRIGGER, "direction"), ], ) @pytest.mark.parametrize( @@ -641,7 +682,7 @@ async def test_direction_template( hass: HomeAssistant, direction: str, expected: bool | None ) -> None: """Test direction template.""" - hass.states.async_set("sensor.direction", direction) + hass.states.async_set(_STATE_TEST_SENSOR, direction) await hass.async_block_till_done() _verify(hass, STATE_ON, None, None, expected, None) @@ -674,6 +715,17 @@ async def test_direction_template( "turn_off": {"service": "script.fan_off"}, }, ), + ( + ConfigurationStyle.TRIGGER, + { + "availability": ("{{ is_state('availability_boolean.state', 'on') }}"), + "state": "{{ 'on' }}", + "oscillating": "{{ 1 == 1 }}", + "direction": "{{ 'forward' }}", + "turn_on": {"service": "script.fan_on"}, + "turn_off": {"service": "script.fan_off"}, + }, + ), ], ) @pytest.mark.usefixtures("setup_named_fan") @@ -707,6 +759,14 @@ async def test_availability_template_with_entities(hass: HomeAssistant) -> None: }, [STATE_OFF, None, None, None], ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'unavailable' }}", + **OPTIMISTIC_ON_OFF_ACTIONS, + }, + [STATE_OFF, None, None, None], + ), ( ConfigurationStyle.LEGACY, { @@ -733,6 +793,19 @@ async def test_availability_template_with_entities(hass: HomeAssistant) -> None: }, [STATE_ON, 0, None, None], ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + "percentage": "{{ 0 }}", + **OPTIMISTIC_PERCENTAGE_CONFIG, + "oscillating": "{{ 'unavailable' }}", + **OSCILLATE_ACTION, + "direction": "{{ 'unavailable' }}", + **DIRECTION_ACTION, + }, + [STATE_ON, 0, None, None], + ), ( ConfigurationStyle.LEGACY, { @@ -759,6 +832,19 @@ async def test_availability_template_with_entities(hass: HomeAssistant) -> None: }, [STATE_ON, 66, True, DIRECTION_FORWARD], ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + "percentage": "{{ 66 }}", + **OPTIMISTIC_PERCENTAGE_CONFIG, + "oscillating": "{{ 1 == 1 }}", + **OSCILLATE_ACTION, + "direction": "{{ 'forward' }}", + **DIRECTION_ACTION, + }, + [STATE_ON, 66, True, DIRECTION_FORWARD], + ), ( ConfigurationStyle.LEGACY, { @@ -785,6 +871,19 @@ async def test_availability_template_with_entities(hass: HomeAssistant) -> None: }, [STATE_OFF, 0, None, None], ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'abc' }}", + "percentage": "{{ 0 }}", + **OPTIMISTIC_PERCENTAGE_CONFIG, + "oscillating": "{{ 'xyz' }}", + **OSCILLATE_ACTION, + "direction": "{{ 'right' }}", + **DIRECTION_ACTION, + }, + [STATE_OFF, 0, None, None], + ), ], ) @pytest.mark.usefixtures("setup_named_fan") @@ -821,16 +920,33 @@ async def test_template_with_unavailable_entities(hass: HomeAssistant, states) - "turn_off": {"service": "script.fan_off"}, }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + "availability": "{{ x - 12 }}", + "preset_mode": ("{{ states('input_select.preset_mode') }}"), + "oscillating": "{{ states('input_select.osc') }}", + "direction": "{{ states('input_select.direction') }}", + "turn_on": {"service": "script.fan_on"}, + "turn_off": {"service": "script.fan_off"}, + }, + ), ], ) @pytest.mark.usefixtures("setup_named_fan") async def test_invalid_availability_template_keeps_component_available( - hass: HomeAssistant, caplog_setup_text + hass: HomeAssistant, caplog_setup_text, caplog: pytest.LogCaptureFixture ) -> None: """Test that an invalid availability keeps the device available.""" - assert hass.states.get("fan.test_fan").state != STATE_UNAVAILABLE - assert "TemplateError" in caplog_setup_text - assert "x" in caplog_setup_text + # Ensure trigger entities update. + hass.states.async_set(_STATE_INPUT_BOOLEAN, STATE_ON) + await hass.async_block_till_done() + + assert hass.states.get(TEST_ENTITY_ID).state != STATE_UNAVAILABLE + + err = "'x' is undefined" + assert err in caplog_setup_text or err in caplog.text @pytest.mark.parametrize(("count", "extra_config"), [(1, OPTIMISTIC_ON_OFF_ACTIONS)]) @@ -849,6 +965,12 @@ async def test_invalid_availability_template_keeps_component_available( "state": "{{ 'off' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'off' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -899,6 +1021,12 @@ async def test_on_off(hass: HomeAssistant, calls: list[ServiceCall]) -> None: "state": "{{ 'off' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'off' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -981,6 +1109,12 @@ async def test_on_with_extra_attributes( "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1008,6 +1142,12 @@ async def test_set_invalid_direction_from_initial_stage(hass: HomeAssistant) -> "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1045,6 +1185,12 @@ async def test_set_osc(hass: HomeAssistant, calls: list[ServiceCall]) -> None: "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1082,6 +1228,12 @@ async def test_set_direction(hass: HomeAssistant, calls: list[ServiceCall]) -> N "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1117,6 +1269,12 @@ async def test_set_invalid_direction( "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1154,6 +1312,12 @@ async def test_preset_modes(hass: HomeAssistant, calls: list[ServiceCall]) -> No "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1198,6 +1362,12 @@ async def test_set_percentage(hass: HomeAssistant, calls: list[ServiceCall]) -> "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1236,7 +1406,7 @@ async def test_increase_decrease_speed( ) @pytest.mark.parametrize( "style", - [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN], + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_named_fan") async def test_optimistic_state(hass: HomeAssistant, calls: list[ServiceCall]) -> None: @@ -1307,7 +1477,8 @@ async def test_optimistic_state(hass: HomeAssistant, calls: list[ServiceCall]) - @pytest.mark.parametrize("count", [1]) @pytest.mark.parametrize( - "style", [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN] + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( ("extra_config", "attribute", "action", "verify_attr", "coro", "value"), @@ -1383,6 +1554,12 @@ async def test_optimistic_attributes( "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1420,6 +1597,12 @@ async def test_increase_decrease_speed_default_speed_count( "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1451,6 +1634,12 @@ async def test_set_invalid_osc_from_initial_state( "state": "{{ 'on' }}", }, ), + ( + ConfigurationStyle.TRIGGER, + { + "state": "{{ 'on' }}", + }, + ), ], ) @pytest.mark.usefixtures("setup_test_fan_with_extra_config") @@ -1474,24 +1663,37 @@ async def test_set_invalid_osc(hass: HomeAssistant, calls: list[ServiceCall]) -> [ ( { - "test_template_cover_01": UNIQUE_ID_CONFIG, - "test_template_cover_02": UNIQUE_ID_CONFIG, + "test_template_fan_01": UNIQUE_ID_CONFIG, + "test_template_fan_02": UNIQUE_ID_CONFIG, }, ConfigurationStyle.LEGACY, ), ( [ { - "name": "test_template_cover_01", + "name": "test_template_fan_01", **UNIQUE_ID_CONFIG, }, { - "name": "test_template_cover_02", + "name": "test_template_fan_02", **UNIQUE_ID_CONFIG, }, ], ConfigurationStyle.MODERN, ), + ( + [ + { + "name": "test_template_fan_01", + **UNIQUE_ID_CONFIG, + }, + { + "name": "test_template_fan_02", + **UNIQUE_ID_CONFIG, + }, + ], + ConfigurationStyle.TRIGGER, + ), ], ) @pytest.mark.usefixtures("setup_fan") @@ -1506,7 +1708,7 @@ async def test_unique_id(hass: HomeAssistant) -> None: ) @pytest.mark.parametrize( "style", - [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN], + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( ("fan_config", "percentage_step"), @@ -1529,7 +1731,7 @@ async def test_speed_percentage_step(hass: HomeAssistant, percentage_step) -> No ) @pytest.mark.parametrize( "style", - [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN], + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.usefixtures("setup_named_fan") async def test_preset_mode_supported_features(hass: HomeAssistant) -> None: @@ -1541,25 +1743,12 @@ async def test_preset_mode_supported_features(hass: HomeAssistant) -> None: assert attributes.get("supported_features") & FanEntityFeature.PRESET_MODE -@pytest.mark.parametrize("count", [1]) @pytest.mark.parametrize( - ("style", "fan_config"), - [ - ( - ConfigurationStyle.LEGACY, - { - "turn_on": [], - "turn_off": [], - }, - ), - ( - ConfigurationStyle.MODERN, - { - "turn_on": [], - "turn_off": [], - }, - ), - ], + ("count", "fan_config"), [(1, {"turn_on": [], "turn_off": []})] +) +@pytest.mark.parametrize( + "style", + [ConfigurationStyle.LEGACY, ConfigurationStyle.MODERN, ConfigurationStyle.TRIGGER], ) @pytest.mark.parametrize( ("extra_config", "supported_features"), @@ -1590,10 +1779,10 @@ async def test_preset_mode_supported_features(hass: HomeAssistant) -> None: ), ], ) +@pytest.mark.usefixtures("setup_test_fan_with_extra_config") async def test_empty_action_config( hass: HomeAssistant, supported_features: FanEntityFeature, - setup_test_fan_with_extra_config, ) -> None: """Test configuration with empty script.""" state = hass.states.get(TEST_ENTITY_ID) From 7f99cd2d2be47424f348e5ec3b110a7daa3190e7 Mon Sep 17 00:00:00 2001 From: Paulus Schoutsen Date: Mon, 23 Jun 2025 15:45:33 -0400 Subject: [PATCH 24/30] Clean up start_subentry_reconfigure_flow API for tests (#147381) --- tests/common.py | 3 +- .../kitchen_sink/test_config_flow.py | 4 +-- tests/components/mqtt/test_config_flow.py | 32 +++++-------------- tests/test_config_entries.py | 8 ++--- 4 files changed, 14 insertions(+), 33 deletions(-) diff --git a/tests/common.py b/tests/common.py index d184d2b46fba95..40d6e4d79d3510 100644 --- a/tests/common.py +++ b/tests/common.py @@ -1184,7 +1184,6 @@ async def start_reconfigure_flow( async def start_subentry_reconfigure_flow( self, hass: HomeAssistant, - subentry_flow_type: str, subentry_id: str, *, show_advanced_options: bool = False, @@ -1194,6 +1193,8 @@ async def start_subentry_reconfigure_flow( raise ValueError( "Config entry must be added to hass to start reconfiguration flow" ) + # Derive subentry_flow_type from the subentry_id + subentry_flow_type = self.subentries[subentry_id].subentry_type return await hass.config_entries.subentries.async_init( (self.entry_id, subentry_flow_type), context={ diff --git a/tests/components/kitchen_sink/test_config_flow.py b/tests/components/kitchen_sink/test_config_flow.py index 88bacc2cb0b312..bc85edc592d7ca 100644 --- a/tests/components/kitchen_sink/test_config_flow.py +++ b/tests/components/kitchen_sink/test_config_flow.py @@ -171,9 +171,7 @@ async def test_subentry_reconfigure_flow(hass: HomeAssistant) -> None: assert await hass.config_entries.async_setup(config_entry.entry_id) await hass.async_block_till_done() - result = await config_entry.start_subentry_reconfigure_flow( - hass, "entity", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.FORM assert result["step_id"] == "reconfigure_sensor" diff --git a/tests/components/mqtt/test_config_flow.py b/tests/components/mqtt/test_config_flow.py index e30aa5d50d6668..a139f729cd9da4 100644 --- a/tests/components/mqtt/test_config_flow.py +++ b/tests/components/mqtt/test_config_flow.py @@ -3309,9 +3309,7 @@ async def test_subentry_reconfigure_remove_entity( subentry_id: str subentry: ConfigSubentry subentry_id, subentry = next(iter(config_entry.subentries.items())) - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" @@ -3433,9 +3431,7 @@ async def test_subentry_reconfigure_edit_entity_multi_entitites( subentry_id: str subentry: ConfigSubentry subentry_id, subentry = next(iter(config_entry.subentries.items())) - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" @@ -3651,9 +3647,7 @@ async def test_subentry_reconfigure_edit_entity_single_entity( subentry_id: str subentry: ConfigSubentry subentry_id, subentry = next(iter(config_entry.subentries.items())) - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" @@ -3795,9 +3789,7 @@ async def test_subentry_reconfigure_edit_entity_reset_fields( subentry_id: str subentry: ConfigSubentry subentry_id, subentry = next(iter(config_entry.subentries.items())) - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" @@ -3924,9 +3916,7 @@ async def test_subentry_reconfigure_add_entity( subentry_id: str subentry: ConfigSubentry subentry_id, subentry = next(iter(config_entry.subentries.items())) - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" @@ -4023,9 +4013,7 @@ async def test_subentry_reconfigure_update_device_properties( subentry_id: str subentry: ConfigSubentry subentry_id, subentry = next(iter(config_entry.subentries.items())) - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" @@ -4124,9 +4112,7 @@ async def test_subentry_reconfigure_availablity( } assert subentry.data.get("availability") == expected_availability - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" @@ -4174,9 +4160,7 @@ async def test_subentry_reconfigure_availablity( assert subentry.data.get("availability") == expected_availability # Assert we can reset the availability config - result = await config_entry.start_subentry_reconfigure_flow( - hass, "device", subentry_id - ) + result = await config_entry.start_subentry_reconfigure_flow(hass, subentry_id) assert result["type"] is FlowResultType.MENU assert result["step_id"] == "summary_menu" result = await hass.config_entries.subentries.async_configure( diff --git a/tests/test_config_entries.py b/tests/test_config_entries.py index 55b8434160e5a4..45bb956b7a1a82 100644 --- a/tests/test_config_entries.py +++ b/tests/test_config_entries.py @@ -6497,9 +6497,7 @@ def async_get_supported_subentry_types( err: Exception with mock_config_flow("comp", TestFlow): try: - result = await entry.start_subentry_reconfigure_flow( - hass, "test", subentry_id - ) + result = await entry.start_subentry_reconfigure_flow(hass, subentry_id) except Exception as ex: # noqa: BLE001 err = ex @@ -6556,7 +6554,7 @@ def async_get_supported_subentry_types( mock_config_flow("comp", TestFlow), pytest.raises(ValueError, match="Source is reconfigure, expected user"), ): - await entry.start_subentry_reconfigure_flow(hass, "test", subentry_id) + await entry.start_subentry_reconfigure_flow(hass, subentry_id) await hass.async_block_till_done() @@ -8079,7 +8077,7 @@ def async_get_supported_subentry_types( # A reconfigure flow finds the config entry and subentry with mock_config_flow("test", TestFlow): - result = await entry.start_subentry_reconfigure_flow(hass, "test", subentry_id) + result = await entry.start_subentry_reconfigure_flow(hass, subentry_id) assert ( result["reason"] == "Found entry entry_title: mock_entry_id/Found subentry Test: mock_subentry_id" From 8b6205be25784792e819ad842699e07d976b2483 Mon Sep 17 00:00:00 2001 From: epenet <6771947+epenet@users.noreply.github.com> Date: Mon, 23 Jun 2025 21:46:51 +0200 Subject: [PATCH 25/30] Remove JuiceNet integration (#147206) --- CODEOWNERS | 2 - homeassistant/components/juicenet/__init__.py | 103 +++----------- .../components/juicenet/config_flow.py | 73 +--------- homeassistant/components/juicenet/const.py | 3 - .../components/juicenet/coordinator.py | 33 ----- homeassistant/components/juicenet/device.py | 21 --- homeassistant/components/juicenet/entity.py | 32 ----- .../components/juicenet/manifest.json | 7 +- homeassistant/components/juicenet/number.py | 93 ------------ homeassistant/components/juicenet/sensor.py | 124 ---------------- .../components/juicenet/strings.json | 41 +----- homeassistant/components/juicenet/switch.py | 53 ------- homeassistant/generated/config_flows.py | 1 - homeassistant/generated/integrations.json | 6 - requirements_all.txt | 3 - requirements_test_all.txt | 3 - tests/components/juicenet/test_config_flow.py | 134 ------------------ tests/components/juicenet/test_init.py | 50 +++++++ 18 files changed, 80 insertions(+), 702 deletions(-) delete mode 100644 homeassistant/components/juicenet/coordinator.py delete mode 100644 homeassistant/components/juicenet/device.py delete mode 100644 homeassistant/components/juicenet/entity.py delete mode 100644 homeassistant/components/juicenet/number.py delete mode 100644 homeassistant/components/juicenet/sensor.py delete mode 100644 homeassistant/components/juicenet/switch.py delete mode 100644 tests/components/juicenet/test_config_flow.py create mode 100644 tests/components/juicenet/test_init.py diff --git a/CODEOWNERS b/CODEOWNERS index 9f312c77b1e5d7..c019f75c57aad6 100644 --- a/CODEOWNERS +++ b/CODEOWNERS @@ -788,8 +788,6 @@ build.json @home-assistant/supervisor /tests/components/jellyfin/ @RunC0deRun @ctalkington /homeassistant/components/jewish_calendar/ @tsvi /tests/components/jewish_calendar/ @tsvi -/homeassistant/components/juicenet/ @jesserockz -/tests/components/juicenet/ @jesserockz /homeassistant/components/justnimbus/ @kvanzuijlen /tests/components/justnimbus/ @kvanzuijlen /homeassistant/components/jvc_projector/ @SteveEasley @msavazzi diff --git a/homeassistant/components/juicenet/__init__.py b/homeassistant/components/juicenet/__init__.py index 6cfdd85c6b7903..5d2c10bcd1c9f6 100644 --- a/homeassistant/components/juicenet/__init__.py +++ b/homeassistant/components/juicenet/__init__.py @@ -1,95 +1,36 @@ """The JuiceNet integration.""" -import logging - -import aiohttp -from pyjuicenet import Api, TokenError -import voluptuous as vol - -from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry -from homeassistant.const import CONF_ACCESS_TOKEN, Platform +from homeassistant.config_entries import ConfigEntry, ConfigEntryState from homeassistant.core import HomeAssistant -from homeassistant.exceptions import ConfigEntryNotReady -from homeassistant.helpers import config_validation as cv -from homeassistant.helpers.aiohttp_client import async_get_clientsession -from homeassistant.helpers.typing import ConfigType - -from .const import DOMAIN, JUICENET_API, JUICENET_COORDINATOR -from .coordinator import JuiceNetCoordinator -from .device import JuiceNetApi - -_LOGGER = logging.getLogger(__name__) - -PLATFORMS = [Platform.NUMBER, Platform.SENSOR, Platform.SWITCH] - -CONFIG_SCHEMA = vol.Schema( - vol.All( - cv.deprecated(DOMAIN), - {DOMAIN: vol.Schema({vol.Required(CONF_ACCESS_TOKEN): cv.string})}, - ), - extra=vol.ALLOW_EXTRA, -) +from homeassistant.helpers import issue_registry as ir - -async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: - """Set up the JuiceNet component.""" - conf = config.get(DOMAIN) - hass.data.setdefault(DOMAIN, {}) - - if not conf: - return True - - hass.async_create_task( - hass.config_entries.flow.async_init( - DOMAIN, context={"source": SOURCE_IMPORT}, data=conf - ) - ) - return True +from .const import DOMAIN async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Set up JuiceNet from a config entry.""" - config = entry.data - - session = async_get_clientsession(hass) - - access_token = config[CONF_ACCESS_TOKEN] - api = Api(access_token, session) - - juicenet = JuiceNetApi(api) - - try: - await juicenet.setup() - except TokenError as error: - _LOGGER.error("JuiceNet Error %s", error) - return False - except aiohttp.ClientError as error: - _LOGGER.error("Could not reach the JuiceNet API %s", error) - raise ConfigEntryNotReady from error - - if not juicenet.devices: - _LOGGER.error("No JuiceNet devices found for this account") - return False - _LOGGER.debug("%d JuiceNet device(s) found", len(juicenet.devices)) - - coordinator = JuiceNetCoordinator(hass, entry, juicenet) - - await coordinator.async_config_entry_first_refresh() - - hass.data[DOMAIN][entry.entry_id] = { - JUICENET_API: juicenet, - JUICENET_COORDINATOR: coordinator, - } - - await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) - + ir.async_create_issue( + hass, + DOMAIN, + DOMAIN, + is_fixable=False, + severity=ir.IssueSeverity.ERROR, + translation_key="integration_removed", + translation_placeholders={ + "entries": "/config/integrations/integration/juicenet", + }, + ) return True async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool: """Unload a config entry.""" - unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS) - if unload_ok: - hass.data[DOMAIN].pop(entry.entry_id) - return unload_ok + if all( + config_entry.state is ConfigEntryState.NOT_LOADED + for config_entry in hass.config_entries.async_entries(DOMAIN) + if config_entry.entry_id != entry.entry_id + ): + ir.async_delete_issue(hass, DOMAIN, DOMAIN) + + return True diff --git a/homeassistant/components/juicenet/config_flow.py b/homeassistant/components/juicenet/config_flow.py index 8bcee5677e69b1..a5da1c504866e0 100644 --- a/homeassistant/components/juicenet/config_flow.py +++ b/homeassistant/components/juicenet/config_flow.py @@ -1,82 +1,11 @@ """Config flow for JuiceNet integration.""" -import logging -from typing import Any - -import aiohttp -from pyjuicenet import Api, TokenError -import voluptuous as vol - -from homeassistant import core, exceptions -from homeassistant.config_entries import ConfigFlow, ConfigFlowResult -from homeassistant.const import CONF_ACCESS_TOKEN -from homeassistant.helpers.aiohttp_client import async_get_clientsession +from homeassistant.config_entries import ConfigFlow from .const import DOMAIN -_LOGGER = logging.getLogger(__name__) - -DATA_SCHEMA = vol.Schema({vol.Required(CONF_ACCESS_TOKEN): str}) - - -async def validate_input(hass: core.HomeAssistant, data): - """Validate the user input allows us to connect. - - Data has the keys from DATA_SCHEMA with values provided by the user. - """ - session = async_get_clientsession(hass) - juicenet = Api(data[CONF_ACCESS_TOKEN], session) - - try: - await juicenet.get_devices() - except TokenError as error: - _LOGGER.error("Token Error %s", error) - raise InvalidAuth from error - except aiohttp.ClientError as error: - _LOGGER.error("Error connecting %s", error) - raise CannotConnect from error - - # Return info that you want to store in the config entry. - return {"title": "JuiceNet"} - class JuiceNetConfigFlow(ConfigFlow, domain=DOMAIN): """Handle a config flow for JuiceNet.""" VERSION = 1 - - async def async_step_user( - self, user_input: dict[str, Any] | None = None - ) -> ConfigFlowResult: - """Handle the initial step.""" - errors = {} - if user_input is not None: - await self.async_set_unique_id(user_input[CONF_ACCESS_TOKEN]) - self._abort_if_unique_id_configured() - - try: - info = await validate_input(self.hass, user_input) - return self.async_create_entry(title=info["title"], data=user_input) - except CannotConnect: - errors["base"] = "cannot_connect" - except InvalidAuth: - errors["base"] = "invalid_auth" - except Exception: - _LOGGER.exception("Unexpected exception") - errors["base"] = "unknown" - - return self.async_show_form( - step_id="user", data_schema=DATA_SCHEMA, errors=errors - ) - - async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult: - """Handle import.""" - return await self.async_step_user(import_data) - - -class CannotConnect(exceptions.HomeAssistantError): - """Error to indicate we cannot connect.""" - - -class InvalidAuth(exceptions.HomeAssistantError): - """Error to indicate there is invalid auth.""" diff --git a/homeassistant/components/juicenet/const.py b/homeassistant/components/juicenet/const.py index 5dc3e5c3e27582..a1072dffb87a9c 100644 --- a/homeassistant/components/juicenet/const.py +++ b/homeassistant/components/juicenet/const.py @@ -1,6 +1,3 @@ """Constants used by the JuiceNet component.""" DOMAIN = "juicenet" - -JUICENET_API = "juicenet_api" -JUICENET_COORDINATOR = "juicenet_coordinator" diff --git a/homeassistant/components/juicenet/coordinator.py b/homeassistant/components/juicenet/coordinator.py deleted file mode 100644 index 7a89416e40066e..00000000000000 --- a/homeassistant/components/juicenet/coordinator.py +++ /dev/null @@ -1,33 +0,0 @@ -"""The JuiceNet integration.""" - -from datetime import timedelta -import logging - -from homeassistant.config_entries import ConfigEntry -from homeassistant.core import HomeAssistant -from homeassistant.helpers.update_coordinator import DataUpdateCoordinator - -from .device import JuiceNetApi - -_LOGGER = logging.getLogger(__name__) - - -class JuiceNetCoordinator(DataUpdateCoordinator[None]): - """Coordinator for JuiceNet.""" - - def __init__( - self, hass: HomeAssistant, entry: ConfigEntry, juicenet_api: JuiceNetApi - ) -> None: - """Initialize the JuiceNet coordinator.""" - super().__init__( - hass, - _LOGGER, - config_entry=entry, - name="JuiceNet", - update_interval=timedelta(seconds=30), - ) - self.juicenet_api = juicenet_api - - async def _async_update_data(self) -> None: - for device in self.juicenet_api.devices: - await device.update_state(True) diff --git a/homeassistant/components/juicenet/device.py b/homeassistant/components/juicenet/device.py deleted file mode 100644 index b38b0efd68a679..00000000000000 --- a/homeassistant/components/juicenet/device.py +++ /dev/null @@ -1,21 +0,0 @@ -"""Adapter to wrap the pyjuicenet api for home assistant.""" - -from pyjuicenet import Api, Charger - - -class JuiceNetApi: - """Represent a connection to JuiceNet.""" - - def __init__(self, api: Api) -> None: - """Create an object from the provided API instance.""" - self.api = api - self._devices: list[Charger] = [] - - async def setup(self) -> None: - """JuiceNet device setup.""" - self._devices = await self.api.get_devices() - - @property - def devices(self) -> list[Charger]: - """Get a list of devices managed by this account.""" - return self._devices diff --git a/homeassistant/components/juicenet/entity.py b/homeassistant/components/juicenet/entity.py deleted file mode 100644 index d54ccb5accb799..00000000000000 --- a/homeassistant/components/juicenet/entity.py +++ /dev/null @@ -1,32 +0,0 @@ -"""Adapter to wrap the pyjuicenet api for home assistant.""" - -from pyjuicenet import Charger - -from homeassistant.helpers.device_registry import DeviceInfo -from homeassistant.helpers.update_coordinator import CoordinatorEntity - -from .const import DOMAIN -from .coordinator import JuiceNetCoordinator - - -class JuiceNetEntity(CoordinatorEntity[JuiceNetCoordinator]): - """Represent a base JuiceNet device.""" - - _attr_has_entity_name = True - - def __init__( - self, device: Charger, key: str, coordinator: JuiceNetCoordinator - ) -> None: - """Initialise the sensor.""" - super().__init__(coordinator) - self.device = device - self.key = key - self._attr_unique_id = f"{device.id}-{key}" - self._attr_device_info = DeviceInfo( - configuration_url=( - f"https://home.juice.net/Portal/Details?unitID={device.id}" - ), - identifiers={(DOMAIN, device.id)}, - manufacturer="JuiceNet", - name=device.name, - ) diff --git a/homeassistant/components/juicenet/manifest.json b/homeassistant/components/juicenet/manifest.json index 979e540af014d2..5bdad83ac1ec52 100644 --- a/homeassistant/components/juicenet/manifest.json +++ b/homeassistant/components/juicenet/manifest.json @@ -1,10 +1,9 @@ { "domain": "juicenet", "name": "JuiceNet", - "codeowners": ["@jesserockz"], - "config_flow": true, + "codeowners": [], "documentation": "https://www.home-assistant.io/integrations/juicenet", + "integration_type": "system", "iot_class": "cloud_polling", - "loggers": ["pyjuicenet"], - "requirements": ["python-juicenet==1.1.0"] + "requirements": [] } diff --git a/homeassistant/components/juicenet/number.py b/homeassistant/components/juicenet/number.py deleted file mode 100644 index ff8c357a115dff..00000000000000 --- a/homeassistant/components/juicenet/number.py +++ /dev/null @@ -1,93 +0,0 @@ -"""Support for controlling juicenet/juicepoint/juicebox based EVSE numbers.""" - -from __future__ import annotations - -from dataclasses import dataclass - -from pyjuicenet import Charger - -from homeassistant.components.number import ( - DEFAULT_MAX_VALUE, - NumberEntity, - NumberEntityDescription, -) -from homeassistant.config_entries import ConfigEntry -from homeassistant.core import HomeAssistant -from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback - -from .const import DOMAIN, JUICENET_API, JUICENET_COORDINATOR -from .coordinator import JuiceNetCoordinator -from .device import JuiceNetApi -from .entity import JuiceNetEntity - - -@dataclass(frozen=True, kw_only=True) -class JuiceNetNumberEntityDescription(NumberEntityDescription): - """An entity description for a JuiceNetNumber.""" - - setter_key: str - native_max_value_key: str | None = None - - -NUMBER_TYPES: tuple[JuiceNetNumberEntityDescription, ...] = ( - JuiceNetNumberEntityDescription( - translation_key="amperage_limit", - key="current_charging_amperage_limit", - native_min_value=6, - native_max_value_key="max_charging_amperage", - native_step=1, - setter_key="set_charging_amperage_limit", - ), -) - - -async def async_setup_entry( - hass: HomeAssistant, - config_entry: ConfigEntry, - async_add_entities: AddConfigEntryEntitiesCallback, -) -> None: - """Set up the JuiceNet Numbers.""" - juicenet_data = hass.data[DOMAIN][config_entry.entry_id] - api: JuiceNetApi = juicenet_data[JUICENET_API] - coordinator: JuiceNetCoordinator = juicenet_data[JUICENET_COORDINATOR] - - entities = [ - JuiceNetNumber(device, description, coordinator) - for device in api.devices - for description in NUMBER_TYPES - ] - async_add_entities(entities) - - -class JuiceNetNumber(JuiceNetEntity, NumberEntity): - """Implementation of a JuiceNet number.""" - - entity_description: JuiceNetNumberEntityDescription - - def __init__( - self, - device: Charger, - description: JuiceNetNumberEntityDescription, - coordinator: JuiceNetCoordinator, - ) -> None: - """Initialise the number.""" - super().__init__(device, description.key, coordinator) - self.entity_description = description - - @property - def native_value(self) -> float | None: - """Return the value of the entity.""" - return getattr(self.device, self.entity_description.key, None) - - @property - def native_max_value(self) -> float: - """Return the maximum value.""" - if self.entity_description.native_max_value_key is not None: - return getattr(self.device, self.entity_description.native_max_value_key) - if self.entity_description.native_max_value is not None: - return self.entity_description.native_max_value - return DEFAULT_MAX_VALUE - - async def async_set_native_value(self, value: float) -> None: - """Update the current value.""" - await getattr(self.device, self.entity_description.setter_key)(value) diff --git a/homeassistant/components/juicenet/sensor.py b/homeassistant/components/juicenet/sensor.py deleted file mode 100644 index e3ae35da2ce920..00000000000000 --- a/homeassistant/components/juicenet/sensor.py +++ /dev/null @@ -1,124 +0,0 @@ -"""Support for monitoring juicenet/juicepoint/juicebox based EVSE sensors.""" - -from __future__ import annotations - -from pyjuicenet import Charger - -from homeassistant.components.sensor import ( - SensorDeviceClass, - SensorEntity, - SensorEntityDescription, - SensorStateClass, -) -from homeassistant.config_entries import ConfigEntry -from homeassistant.const import ( - UnitOfElectricCurrent, - UnitOfElectricPotential, - UnitOfEnergy, - UnitOfPower, - UnitOfTemperature, - UnitOfTime, -) -from homeassistant.core import HomeAssistant -from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback - -from .const import DOMAIN, JUICENET_API, JUICENET_COORDINATOR -from .coordinator import JuiceNetCoordinator -from .device import JuiceNetApi -from .entity import JuiceNetEntity - -SENSOR_TYPES: tuple[SensorEntityDescription, ...] = ( - SensorEntityDescription( - key="status", - name="Charging Status", - ), - SensorEntityDescription( - key="temperature", - native_unit_of_measurement=UnitOfTemperature.CELSIUS, - device_class=SensorDeviceClass.TEMPERATURE, - state_class=SensorStateClass.MEASUREMENT, - ), - SensorEntityDescription( - key="voltage", - native_unit_of_measurement=UnitOfElectricPotential.VOLT, - device_class=SensorDeviceClass.VOLTAGE, - ), - SensorEntityDescription( - key="amps", - native_unit_of_measurement=UnitOfElectricCurrent.AMPERE, - device_class=SensorDeviceClass.CURRENT, - state_class=SensorStateClass.MEASUREMENT, - ), - SensorEntityDescription( - key="watts", - native_unit_of_measurement=UnitOfPower.WATT, - device_class=SensorDeviceClass.POWER, - state_class=SensorStateClass.MEASUREMENT, - ), - SensorEntityDescription( - key="charge_time", - translation_key="charge_time", - native_unit_of_measurement=UnitOfTime.SECONDS, - icon="mdi:timer-outline", - ), - SensorEntityDescription( - key="energy_added", - translation_key="energy_added", - native_unit_of_measurement=UnitOfEnergy.WATT_HOUR, - device_class=SensorDeviceClass.ENERGY, - state_class=SensorStateClass.TOTAL_INCREASING, - ), -) - - -async def async_setup_entry( - hass: HomeAssistant, - config_entry: ConfigEntry, - async_add_entities: AddConfigEntryEntitiesCallback, -) -> None: - """Set up the JuiceNet Sensors.""" - juicenet_data = hass.data[DOMAIN][config_entry.entry_id] - api: JuiceNetApi = juicenet_data[JUICENET_API] - coordinator: JuiceNetCoordinator = juicenet_data[JUICENET_COORDINATOR] - - entities = [ - JuiceNetSensorDevice(device, coordinator, description) - for device in api.devices - for description in SENSOR_TYPES - ] - async_add_entities(entities) - - -class JuiceNetSensorDevice(JuiceNetEntity, SensorEntity): - """Implementation of a JuiceNet sensor.""" - - def __init__( - self, - device: Charger, - coordinator: JuiceNetCoordinator, - description: SensorEntityDescription, - ) -> None: - """Initialise the sensor.""" - super().__init__(device, description.key, coordinator) - self.entity_description = description - - @property - def icon(self): - """Return the icon of the sensor.""" - icon = None - if self.entity_description.key == "status": - status = self.device.status - if status == "standby": - icon = "mdi:power-plug-off" - elif status == "plugged": - icon = "mdi:power-plug" - elif status == "charging": - icon = "mdi:battery-positive" - else: - icon = self.entity_description.icon - return icon - - @property - def native_value(self): - """Return the state.""" - return getattr(self.device, self.entity_description.key, None) diff --git a/homeassistant/components/juicenet/strings.json b/homeassistant/components/juicenet/strings.json index 0e3732c66d2bfa..6e25130955b11b 100644 --- a/homeassistant/components/juicenet/strings.json +++ b/homeassistant/components/juicenet/strings.json @@ -1,41 +1,8 @@ { - "config": { - "abort": { - "already_configured": "[%key:common::config_flow::abort::already_configured_account%]" - }, - "error": { - "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]", - "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]", - "unknown": "[%key:common::config_flow::error::unknown%]" - }, - "step": { - "user": { - "data": { - "api_token": "[%key:common::config_flow::data::api_token%]" - }, - "description": "You will need the API Token from https://home.juice.net/Manage.", - "title": "Connect to JuiceNet" - } - } - }, - "entity": { - "number": { - "amperage_limit": { - "name": "Amperage limit" - } - }, - "sensor": { - "charge_time": { - "name": "Charge time" - }, - "energy_added": { - "name": "Energy added" - } - }, - "switch": { - "charge_now": { - "name": "Charge now" - } + "issues": { + "integration_removed": { + "title": "The JuiceNet integration has been removed", + "description": "Enel X has dropped support for JuiceNet in favor of JuicePass, and the JuiceNet integration has been removed from Home Assistant as it was no longer working.\n\nTo resolve this issue, please remove the (now defunct) integration entries from your Home Assistant setup. [Click here to see your existing JuiceNet integration entries]({entries})." } } } diff --git a/homeassistant/components/juicenet/switch.py b/homeassistant/components/juicenet/switch.py deleted file mode 100644 index e8a16e9da8f3fe..00000000000000 --- a/homeassistant/components/juicenet/switch.py +++ /dev/null @@ -1,53 +0,0 @@ -"""Support for monitoring juicenet/juicepoint/juicebox based EVSE switches.""" - -from typing import Any - -from pyjuicenet import Charger - -from homeassistant.components.switch import SwitchEntity -from homeassistant.config_entries import ConfigEntry -from homeassistant.core import HomeAssistant -from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback - -from .const import DOMAIN, JUICENET_API, JUICENET_COORDINATOR -from .coordinator import JuiceNetCoordinator -from .device import JuiceNetApi -from .entity import JuiceNetEntity - - -async def async_setup_entry( - hass: HomeAssistant, - config_entry: ConfigEntry, - async_add_entities: AddConfigEntryEntitiesCallback, -) -> None: - """Set up the JuiceNet switches.""" - juicenet_data = hass.data[DOMAIN][config_entry.entry_id] - api: JuiceNetApi = juicenet_data[JUICENET_API] - coordinator: JuiceNetCoordinator = juicenet_data[JUICENET_COORDINATOR] - - async_add_entities( - JuiceNetChargeNowSwitch(device, coordinator) for device in api.devices - ) - - -class JuiceNetChargeNowSwitch(JuiceNetEntity, SwitchEntity): - """Implementation of a JuiceNet switch.""" - - _attr_translation_key = "charge_now" - - def __init__(self, device: Charger, coordinator: JuiceNetCoordinator) -> None: - """Initialise the switch.""" - super().__init__(device, "charge_now", coordinator) - - @property - def is_on(self): - """Return true if switch is on.""" - return self.device.override_time != 0 - - async def async_turn_on(self, **kwargs: Any) -> None: - """Charge now.""" - await self.device.set_override(True) - - async def async_turn_off(self, **kwargs: Any) -> None: - """Don't charge now.""" - await self.device.set_override(False) diff --git a/homeassistant/generated/config_flows.py b/homeassistant/generated/config_flows.py index b9dfefd3327f6d..9a7408ad8b1792 100644 --- a/homeassistant/generated/config_flows.py +++ b/homeassistant/generated/config_flows.py @@ -314,7 +314,6 @@ "izone", "jellyfin", "jewish_calendar", - "juicenet", "justnimbus", "jvc_projector", "kaleidescape", diff --git a/homeassistant/generated/integrations.json b/homeassistant/generated/integrations.json index b3918ac8ded62c..8b65ebfb66a33a 100644 --- a/homeassistant/generated/integrations.json +++ b/homeassistant/generated/integrations.json @@ -3181,12 +3181,6 @@ "config_flow": false, "iot_class": "cloud_push" }, - "juicenet": { - "name": "JuiceNet", - "integration_type": "hub", - "config_flow": true, - "iot_class": "cloud_polling" - }, "justnimbus": { "name": "JustNimbus", "integration_type": "hub", diff --git a/requirements_all.txt b/requirements_all.txt index f6de99444c8166..8e827b6a4a3426 100644 --- a/requirements_all.txt +++ b/requirements_all.txt @@ -2449,9 +2449,6 @@ python-izone==1.2.9 # homeassistant.components.joaoapps_join python-join-api==0.0.9 -# homeassistant.components.juicenet -python-juicenet==1.1.0 - # homeassistant.components.tplink python-kasa[speedups]==0.10.2 diff --git a/requirements_test_all.txt b/requirements_test_all.txt index 8cd601e2613521..20390c2ade97e8 100644 --- a/requirements_test_all.txt +++ b/requirements_test_all.txt @@ -2019,9 +2019,6 @@ python-homewizard-energy==9.1.1 # homeassistant.components.izone python-izone==1.2.9 -# homeassistant.components.juicenet -python-juicenet==1.1.0 - # homeassistant.components.tplink python-kasa[speedups]==0.10.2 diff --git a/tests/components/juicenet/test_config_flow.py b/tests/components/juicenet/test_config_flow.py deleted file mode 100644 index 48d63cd8cd0804..00000000000000 --- a/tests/components/juicenet/test_config_flow.py +++ /dev/null @@ -1,134 +0,0 @@ -"""Test the JuiceNet config flow.""" - -from unittest.mock import MagicMock, patch - -import aiohttp -from pyjuicenet import TokenError - -from homeassistant import config_entries -from homeassistant.components.juicenet.const import DOMAIN -from homeassistant.const import CONF_ACCESS_TOKEN -from homeassistant.core import HomeAssistant -from homeassistant.data_entry_flow import FlowResultType - - -def _mock_juicenet_return_value(get_devices=None): - juicenet_mock = MagicMock() - type(juicenet_mock).get_devices = MagicMock(return_value=get_devices) - return juicenet_mock - - -async def test_form(hass: HomeAssistant) -> None: - """Test we get the form.""" - - result = await hass.config_entries.flow.async_init( - DOMAIN, context={"source": config_entries.SOURCE_USER} - ) - assert result["type"] is FlowResultType.FORM - assert result["errors"] == {} - - with ( - patch( - "homeassistant.components.juicenet.config_flow.Api.get_devices", - return_value=MagicMock(), - ), - patch( - "homeassistant.components.juicenet.async_setup", return_value=True - ) as mock_setup, - patch( - "homeassistant.components.juicenet.async_setup_entry", return_value=True - ) as mock_setup_entry, - ): - result2 = await hass.config_entries.flow.async_configure( - result["flow_id"], {CONF_ACCESS_TOKEN: "access_token"} - ) - await hass.async_block_till_done() - - assert result2["type"] is FlowResultType.CREATE_ENTRY - assert result2["title"] == "JuiceNet" - assert result2["data"] == {CONF_ACCESS_TOKEN: "access_token"} - assert len(mock_setup.mock_calls) == 1 - assert len(mock_setup_entry.mock_calls) == 1 - - -async def test_form_invalid_auth(hass: HomeAssistant) -> None: - """Test we handle invalid auth.""" - result = await hass.config_entries.flow.async_init( - DOMAIN, context={"source": config_entries.SOURCE_USER} - ) - - with patch( - "homeassistant.components.juicenet.config_flow.Api.get_devices", - side_effect=TokenError, - ): - result2 = await hass.config_entries.flow.async_configure( - result["flow_id"], {CONF_ACCESS_TOKEN: "access_token"} - ) - - assert result2["type"] is FlowResultType.FORM - assert result2["errors"] == {"base": "invalid_auth"} - - -async def test_form_cannot_connect(hass: HomeAssistant) -> None: - """Test we handle cannot connect error.""" - result = await hass.config_entries.flow.async_init( - DOMAIN, context={"source": config_entries.SOURCE_USER} - ) - - with patch( - "homeassistant.components.juicenet.config_flow.Api.get_devices", - side_effect=aiohttp.ClientError, - ): - result2 = await hass.config_entries.flow.async_configure( - result["flow_id"], {CONF_ACCESS_TOKEN: "access_token"} - ) - - assert result2["type"] is FlowResultType.FORM - assert result2["errors"] == {"base": "cannot_connect"} - - -async def test_form_catch_unknown_errors(hass: HomeAssistant) -> None: - """Test we handle cannot connect error.""" - result = await hass.config_entries.flow.async_init( - DOMAIN, context={"source": config_entries.SOURCE_USER} - ) - - with patch( - "homeassistant.components.juicenet.config_flow.Api.get_devices", - side_effect=Exception, - ): - result2 = await hass.config_entries.flow.async_configure( - result["flow_id"], {CONF_ACCESS_TOKEN: "access_token"} - ) - - assert result2["type"] is FlowResultType.FORM - assert result2["errors"] == {"base": "unknown"} - - -async def test_import(hass: HomeAssistant) -> None: - """Test that import works as expected.""" - - with ( - patch( - "homeassistant.components.juicenet.config_flow.Api.get_devices", - return_value=MagicMock(), - ), - patch( - "homeassistant.components.juicenet.async_setup", return_value=True - ) as mock_setup, - patch( - "homeassistant.components.juicenet.async_setup_entry", return_value=True - ) as mock_setup_entry, - ): - result = await hass.config_entries.flow.async_init( - DOMAIN, - context={"source": config_entries.SOURCE_IMPORT}, - data={CONF_ACCESS_TOKEN: "access_token"}, - ) - await hass.async_block_till_done() - - assert result["type"] is FlowResultType.CREATE_ENTRY - assert result["title"] == "JuiceNet" - assert result["data"] == {CONF_ACCESS_TOKEN: "access_token"} - assert len(mock_setup.mock_calls) == 1 - assert len(mock_setup_entry.mock_calls) == 1 diff --git a/tests/components/juicenet/test_init.py b/tests/components/juicenet/test_init.py new file mode 100644 index 00000000000000..8896798abe32e2 --- /dev/null +++ b/tests/components/juicenet/test_init.py @@ -0,0 +1,50 @@ +"""Tests for the JuiceNet component.""" + +from homeassistant.components.juicenet import DOMAIN +from homeassistant.config_entries import ConfigEntryState +from homeassistant.core import HomeAssistant +from homeassistant.helpers import issue_registry as ir + +from tests.common import MockConfigEntry + + +async def test_juicenet_repair_issue( + hass: HomeAssistant, issue_registry: ir.IssueRegistry +) -> None: + """Test the JuiceNet configuration entry loading/unloading handles the repair.""" + config_entry_1 = MockConfigEntry( + title="Example 1", + domain=DOMAIN, + ) + config_entry_1.add_to_hass(hass) + await hass.config_entries.async_setup(config_entry_1.entry_id) + await hass.async_block_till_done() + assert config_entry_1.state is ConfigEntryState.LOADED + + # Add a second one + config_entry_2 = MockConfigEntry( + title="Example 2", + domain=DOMAIN, + ) + config_entry_2.add_to_hass(hass) + await hass.config_entries.async_setup(config_entry_2.entry_id) + await hass.async_block_till_done() + + assert config_entry_2.state is ConfigEntryState.LOADED + assert issue_registry.async_get_issue(DOMAIN, DOMAIN) + + # Remove the first one + await hass.config_entries.async_remove(config_entry_1.entry_id) + await hass.async_block_till_done() + + assert config_entry_1.state is ConfigEntryState.NOT_LOADED + assert config_entry_2.state is ConfigEntryState.LOADED + assert issue_registry.async_get_issue(DOMAIN, DOMAIN) + + # Remove the second one + await hass.config_entries.async_remove(config_entry_2.entry_id) + await hass.async_block_till_done() + + assert config_entry_1.state is ConfigEntryState.NOT_LOADED + assert config_entry_2.state is ConfigEntryState.NOT_LOADED + assert issue_registry.async_get_issue(DOMAIN, DOMAIN) is None From dc948e3b6c12775c3e1c455410f6304a4740c649 Mon Sep 17 00:00:00 2001 From: hanwg Date: Tue, 24 Jun 2025 04:22:00 +0800 Subject: [PATCH 26/30] Add strict typing for Telegram bot integration (#147262) add strict typing --- .strict-typing | 1 + homeassistant/components/telegram_bot/bot.py | 139 ++++++++++++------ .../components/telegram_bot/polling.py | 10 +- .../components/telegram_bot/webhooks.py | 28 ++-- mypy.ini | 10 ++ 5 files changed, 128 insertions(+), 60 deletions(-) diff --git a/.strict-typing b/.strict-typing index 68d67ae85b2f9b..a76ba3885bc283 100644 --- a/.strict-typing +++ b/.strict-typing @@ -503,6 +503,7 @@ homeassistant.components.tautulli.* homeassistant.components.tcp.* homeassistant.components.technove.* homeassistant.components.tedee.* +homeassistant.components.telegram_bot.* homeassistant.components.text.* homeassistant.components.thethingsnetwork.* homeassistant.components.threshold.* diff --git a/homeassistant/components/telegram_bot/bot.py b/homeassistant/components/telegram_bot/bot.py index f313972635f197..9debc7bbbf1074 100644 --- a/homeassistant/components/telegram_bot/bot.py +++ b/homeassistant/components/telegram_bot/bot.py @@ -2,8 +2,10 @@ from abc import abstractmethod import asyncio +from collections.abc import Callable, Sequence import io import logging +from ssl import SSLContext from types import MappingProxyType from typing import Any @@ -13,6 +15,7 @@ CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup, + InputPollOption, Message, ReplyKeyboardMarkup, ReplyKeyboardRemove, @@ -262,7 +265,9 @@ def _get_allowed_chat_ids(self) -> list[int]: return allowed_chat_ids - def _get_msg_ids(self, msg_data, chat_id): + def _get_msg_ids( + self, msg_data: dict[str, Any], chat_id: int + ) -> tuple[Any | None, int | None]: """Get the message id to edit. This can be one of (message_id, inline_message_id) from a msg dict, @@ -270,7 +275,8 @@ def _get_msg_ids(self, msg_data, chat_id): **You can use 'last' as message_id** to edit the message last sent in the chat_id. """ - message_id = inline_message_id = None + message_id: Any | None = None + inline_message_id: int | None = None if ATTR_MESSAGEID in msg_data: message_id = msg_data[ATTR_MESSAGEID] if ( @@ -283,7 +289,7 @@ def _get_msg_ids(self, msg_data, chat_id): inline_message_id = msg_data["inline_message_id"] return message_id, inline_message_id - def _get_target_chat_ids(self, target): + def _get_target_chat_ids(self, target: Any) -> list[int]: """Validate chat_id targets or return default target (first). :param target: optional list of integers ([12234, -12345]) @@ -302,10 +308,10 @@ def _get_target_chat_ids(self, target): ) return [default_user] - def _get_msg_kwargs(self, data): + def _get_msg_kwargs(self, data: dict[str, Any]) -> dict[str, Any]: """Get parameters in message data kwargs.""" - def _make_row_inline_keyboard(row_keyboard): + def _make_row_inline_keyboard(row_keyboard: Any) -> list[InlineKeyboardButton]: """Make a list of InlineKeyboardButtons. It can accept: @@ -350,7 +356,7 @@ def _make_row_inline_keyboard(row_keyboard): return buttons # Defaults - params = { + params: dict[str, Any] = { ATTR_PARSER: self.parse_mode, ATTR_DISABLE_NOTIF: False, ATTR_DISABLE_WEB_PREV: None, @@ -399,8 +405,14 @@ def _make_row_inline_keyboard(row_keyboard): return params async def _send_msg( - self, func_send, msg_error, message_tag, *args_msg, context=None, **kwargs_msg - ): + self, + func_send: Callable, + msg_error: str, + message_tag: str | None, + *args_msg: Any, + context: Context | None = None, + **kwargs_msg: Any, + ) -> Any: """Send one message.""" try: out = await func_send(*args_msg, **kwargs_msg) @@ -438,7 +450,13 @@ async def _send_msg( return None return out - async def send_message(self, message="", target=None, context=None, **kwargs): + async def send_message( + self, + message: str = "", + target: Any = None, + context: Context | None = None, + **kwargs: dict[str, Any], + ) -> dict[int, int]: """Send a message to one or multiple pre-allowed chat IDs.""" title = kwargs.get(ATTR_TITLE) text = f"{title}\n{message}" if title else message @@ -465,12 +483,17 @@ async def send_message(self, message="", target=None, context=None, **kwargs): msg_ids[chat_id] = msg.id return msg_ids - async def delete_message(self, chat_id=None, context=None, **kwargs): + async def delete_message( + self, + chat_id: int | None = None, + context: Context | None = None, + **kwargs: dict[str, Any], + ) -> bool: """Delete a previously sent message.""" chat_id = self._get_target_chat_ids(chat_id)[0] message_id, _ = self._get_msg_ids(kwargs, chat_id) _LOGGER.debug("Delete message %s in chat ID %s", message_id, chat_id) - deleted = await self._send_msg( + deleted: bool = await self._send_msg( self.bot.delete_message, "Error deleting message", None, @@ -484,7 +507,13 @@ async def delete_message(self, chat_id=None, context=None, **kwargs): self._last_message_id[chat_id] -= 1 return deleted - async def edit_message(self, type_edit, chat_id=None, context=None, **kwargs): + async def edit_message( + self, + type_edit: str, + chat_id: int | None = None, + context: Context | None = None, + **kwargs: dict[str, Any], + ) -> Any: """Edit a previously sent message.""" chat_id = self._get_target_chat_ids(chat_id)[0] message_id, inline_message_id = self._get_msg_ids(kwargs, chat_id) @@ -542,8 +571,13 @@ async def edit_message(self, type_edit, chat_id=None, context=None, **kwargs): ) async def answer_callback_query( - self, message, callback_query_id, show_alert=False, context=None, **kwargs - ): + self, + message: str | None, + callback_query_id: str, + show_alert: bool = False, + context: Context | None = None, + **kwargs: dict[str, Any], + ) -> None: """Answer a callback originated with a press in an inline keyboard.""" params = self._get_msg_kwargs(kwargs) _LOGGER.debug( @@ -564,16 +598,20 @@ async def answer_callback_query( ) async def send_file( - self, file_type=SERVICE_SEND_PHOTO, target=None, context=None, **kwargs - ): + self, + file_type: str, + target: Any = None, + context: Context | None = None, + **kwargs: Any, + ) -> dict[int, int]: """Send a photo, sticker, video, or document.""" params = self._get_msg_kwargs(kwargs) file_content = await load_data( self.hass, url=kwargs.get(ATTR_URL), filepath=kwargs.get(ATTR_FILE), - username=kwargs.get(ATTR_USERNAME), - password=kwargs.get(ATTR_PASSWORD), + username=kwargs.get(ATTR_USERNAME, ""), + password=kwargs.get(ATTR_PASSWORD, ""), authentication=kwargs.get(ATTR_AUTHENTICATION), verify_ssl=( get_default_context() @@ -690,7 +728,12 @@ async def send_file( return msg_ids - async def send_sticker(self, target=None, context=None, **kwargs) -> dict: + async def send_sticker( + self, + target: Any = None, + context: Context | None = None, + **kwargs: Any, + ) -> dict[int, int]: """Send a sticker from a telegram sticker pack.""" params = self._get_msg_kwargs(kwargs) stickerid = kwargs.get(ATTR_STICKER_ID) @@ -713,11 +756,16 @@ async def send_sticker(self, target=None, context=None, **kwargs) -> dict: ) msg_ids[chat_id] = msg.id return msg_ids - return await self.send_file(SERVICE_SEND_STICKER, target, **kwargs) + return await self.send_file(SERVICE_SEND_STICKER, target, context, **kwargs) async def send_location( - self, latitude, longitude, target=None, context=None, **kwargs - ): + self, + latitude: Any, + longitude: Any, + target: Any = None, + context: Context | None = None, + **kwargs: dict[str, Any], + ) -> dict[int, int]: """Send a location.""" latitude = float(latitude) longitude = float(longitude) @@ -745,14 +793,14 @@ async def send_location( async def send_poll( self, - question, - options, - is_anonymous, - allows_multiple_answers, - target=None, - context=None, - **kwargs, - ): + question: str, + options: Sequence[str | InputPollOption], + is_anonymous: bool | None, + allows_multiple_answers: bool | None, + target: Any = None, + context: Context | None = None, + **kwargs: dict[str, Any], + ) -> dict[int, int]: """Send a poll.""" params = self._get_msg_kwargs(kwargs) openperiod = kwargs.get(ATTR_OPEN_PERIOD) @@ -778,7 +826,12 @@ async def send_poll( msg_ids[chat_id] = msg.id return msg_ids - async def leave_chat(self, chat_id=None, context=None, **kwargs): + async def leave_chat( + self, + chat_id: Any = None, + context: Context | None = None, + **kwargs: dict[str, Any], + ) -> Any: """Remove bot from chat.""" chat_id = self._get_target_chat_ids(chat_id)[0] _LOGGER.debug("Leave from chat ID %s", chat_id) @@ -792,7 +845,7 @@ async def set_message_reaction( reaction: str, is_big: bool = False, context: Context | None = None, - **kwargs, + **kwargs: dict[str, Any], ) -> None: """Set the bot's reaction for a given message.""" chat_id = self._get_target_chat_ids(chat_id)[0] @@ -878,19 +931,19 @@ def initialize_bot(hass: HomeAssistant, p_config: MappingProxyType[str, Any]) -> async def load_data( hass: HomeAssistant, - url=None, - filepath=None, - username=None, - password=None, - authentication=None, - num_retries=5, - verify_ssl=None, -): + url: str | None, + filepath: str | None, + username: str, + password: str, + authentication: str | None, + verify_ssl: SSLContext, + num_retries: int = 5, +) -> io.BytesIO: """Load data into ByteIO/File container from a source.""" if url is not None: # Load data from URL params: dict[str, Any] = {} - headers = {} + headers: dict[str, str] = {} _validate_credentials_input(authentication, username, password) if authentication == HTTP_BEARER_AUTHENTICATION: headers = {"Authorization": f"Bearer {password}"} @@ -963,7 +1016,7 @@ def _validate_credentials_input( ) -> None: if ( authentication in (HTTP_BASIC_AUTHENTICATION, HTTP_DIGEST_AUTHENTICATION) - and username is None + and not username ): raise ServiceValidationError( "Username is required.", @@ -979,7 +1032,7 @@ def _validate_credentials_input( HTTP_BEARER_AUTHENTICATION, HTTP_BEARER_AUTHENTICATION, ) - and password is None + and not password ): raise ServiceValidationError( "Password is required.", diff --git a/homeassistant/components/telegram_bot/polling.py b/homeassistant/components/telegram_bot/polling.py index f9e69080939fd5..6c38a0e53b8d2d 100644 --- a/homeassistant/components/telegram_bot/polling.py +++ b/homeassistant/components/telegram_bot/polling.py @@ -64,16 +64,18 @@ async def shutdown(self) -> None: """Shutdown the app.""" await self.stop_polling() - async def start_polling(self, event=None): + async def start_polling(self) -> None: """Start the polling task.""" _LOGGER.debug("Starting polling") await self.application.initialize() - await self.application.updater.start_polling(error_callback=error_callback) + if self.application.updater: + await self.application.updater.start_polling(error_callback=error_callback) await self.application.start() - async def stop_polling(self, event=None): + async def stop_polling(self) -> None: """Stop the polling task.""" _LOGGER.debug("Stopping polling") - await self.application.updater.stop() + if self.application.updater: + await self.application.updater.stop() await self.application.stop() await self.application.shutdown() diff --git a/homeassistant/components/telegram_bot/webhooks.py b/homeassistant/components/telegram_bot/webhooks.py index 9218bcbcd67b8a..0bfad34681a62b 100644 --- a/homeassistant/components/telegram_bot/webhooks.py +++ b/homeassistant/components/telegram_bot/webhooks.py @@ -6,11 +6,12 @@ import secrets import string +from aiohttp.web_response import Response from telegram import Bot, Update from telegram.error import NetworkError, TelegramError -from telegram.ext import ApplicationBuilder, TypeHandler +from telegram.ext import Application, ApplicationBuilder, TypeHandler -from homeassistant.components.http import HomeAssistantView +from homeassistant.components.http import HomeAssistantRequest, HomeAssistantView from homeassistant.const import CONF_URL from homeassistant.core import HomeAssistant from homeassistant.exceptions import ConfigEntryNotReady @@ -87,7 +88,7 @@ async def shutdown(self) -> None: """Shutdown the app.""" await self.stop_application() - async def _try_to_set_webhook(self): + async def _try_to_set_webhook(self) -> bool: _LOGGER.debug("Registering webhook URL: %s", self.webhook_url) retry_num = 0 while retry_num < 3: @@ -103,12 +104,12 @@ async def _try_to_set_webhook(self): return False - async def start_application(self): + async def start_application(self) -> None: """Handle starting the Application object.""" await self.application.initialize() await self.application.start() - async def register_webhook(self): + async def register_webhook(self) -> bool: """Query telegram and register the URL for our webhook.""" current_status = await self.bot.get_webhook_info() # Some logging of Bot current status: @@ -123,13 +124,13 @@ async def register_webhook(self): return True - async def stop_application(self, event=None): + async def stop_application(self) -> None: """Handle gracefully stopping the Application object.""" await self.deregister_webhook() await self.application.stop() await self.application.shutdown() - async def deregister_webhook(self): + async def deregister_webhook(self) -> None: """Query telegram and deregister the URL for our webhook.""" _LOGGER.debug("Deregistering webhook URL") try: @@ -149,7 +150,7 @@ def __init__( self, hass: HomeAssistant, bot: Bot, - application, + application: Application, trusted_networks: list[IPv4Network], secret_token: str, ) -> None: @@ -160,15 +161,16 @@ def __init__( self.trusted_networks = trusted_networks self.secret_token = secret_token - async def post(self, request): + async def post(self, request: HomeAssistantRequest) -> Response | None: """Accept the POST from telegram.""" - real_ip = ip_address(request.remote) - if not any(real_ip in net for net in self.trusted_networks): - _LOGGER.warning("Access denied from %s", real_ip) + if not request.remote or not any( + ip_address(request.remote) in net for net in self.trusted_networks + ): + _LOGGER.warning("Access denied from %s", request.remote) return self.json_message("Access denied", HTTPStatus.UNAUTHORIZED) secret_token_header = request.headers.get("X-Telegram-Bot-Api-Secret-Token") if secret_token_header is None or self.secret_token != secret_token_header: - _LOGGER.warning("Invalid secret token from %s", real_ip) + _LOGGER.warning("Invalid secret token from %s", request.remote) return self.json_message("Access denied", HTTPStatus.UNAUTHORIZED) try: diff --git a/mypy.ini b/mypy.ini index 72e52b67959a42..a6b673be03b1f5 100644 --- a/mypy.ini +++ b/mypy.ini @@ -4788,6 +4788,16 @@ disallow_untyped_defs = true warn_return_any = true warn_unreachable = true +[mypy-homeassistant.components.telegram_bot.*] +check_untyped_defs = true +disallow_incomplete_defs = true +disallow_subclassing_any = true +disallow_untyped_calls = true +disallow_untyped_decorators = true +disallow_untyped_defs = true +warn_return_any = true +warn_unreachable = true + [mypy-homeassistant.components.text.*] check_untyped_defs = true disallow_incomplete_defs = true From 9b915e996b55b15e9334be5f175169758a89701c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C3=85ke=20Strandberg?= Date: Mon, 23 Jun 2025 22:40:46 +0200 Subject: [PATCH 27/30] Refactor states and strings for Miele plate power steps (#144992) * WIP * Fix type check * Empty commit --- homeassistant/components/miele/const.py | 27 ++ homeassistant/components/miele/icons.json | 45 +- homeassistant/components/miele/sensor.py | 48 +- homeassistant/components/miele/strings.json | 45 +- .../miele/snapshots/test_sensor.ambr | 450 ++++++++---------- 5 files changed, 288 insertions(+), 327 deletions(-) diff --git a/homeassistant/components/miele/const.py b/homeassistant/components/miele/const.py index bda276c6d8a899..fd2f8631cd2026 100644 --- a/homeassistant/components/miele/const.py +++ b/homeassistant/components/miele/const.py @@ -1294,3 +1294,30 @@ class StateDryingStep(MieleEnum): MieleAppliance.ROBOT_VACUUM_CLEANER: ROBOT_VACUUM_CLEANER_PROGRAM_ID, MieleAppliance.COFFEE_SYSTEM: COFFEE_SYSTEM_PROGRAM_ID, } + + +class PlatePowerStep(MieleEnum): + """Plate power settings.""" + + plate_step_0 = 0 + plate_step_warming = 110, 220 + plate_step_1 = 1 + plate_step_2 = 2 + plate_step_3 = 3 + plate_step_4 = 4 + plate_step_5 = 5 + plate_step_6 = 6 + plate_step_7 = 7 + plate_step_8 = 8 + plate_step_9 = 9 + plate_step_10 = 10 + plate_step_11 = 11 + plate_step_12 = 12 + plate_step_13 = 13 + plate_step_14 = 4 + plate_step_15 = 15 + plate_step_16 = 16 + plate_step_17 = 17 + plate_step_18 = 18 + plate_step_boost = 117, 118, 218 + missing2none = -9999 diff --git a/homeassistant/components/miele/icons.json b/homeassistant/components/miele/icons.json index 1806fe688d6075..44b51a67c245ef 100644 --- a/homeassistant/components/miele/icons.json +++ b/homeassistant/components/miele/icons.json @@ -56,30 +56,27 @@ "plate": { "default": "mdi:circle-outline", "state": { - "0": "mdi:circle-outline", - "110": "mdi:alpha-w-circle-outline", - "220": "mdi:alpha-w-circle-outline", - "1": "mdi:circle-slice-1", - "2": "mdi:circle-slice-1", - "3": "mdi:circle-slice-2", - "4": "mdi:circle-slice-2", - "5": "mdi:circle-slice-3", - "6": "mdi:circle-slice-3", - "7": "mdi:circle-slice-4", - "8": "mdi:circle-slice-4", - "9": "mdi:circle-slice-5", - "10": "mdi:circle-slice-5", - "11": "mdi:circle-slice-5", - "12": "mdi:circle-slice-6", - "13": "mdi:circle-slice-6", - "14": "mdi:circle-slice-6", - "15": "mdi:circle-slice-7", - "16": "mdi:circle-slice-7", - "17": "mdi:circle-slice-8", - "18": "mdi:circle-slice-8", - "117": "mdi:alpha-b-circle-outline", - "118": "mdi:alpha-b-circle-outline", - "217": "mdi:alpha-b-circle-outline" + "plate_step_0": "mdi:circle-outline", + "plate_step_warming": "mdi:alpha-w-circle-outline", + "plate_step_1": "mdi:circle-slice-1", + "plate_step_2": "mdi:circle-slice-1", + "plate_step_3": "mdi:circle-slice-2", + "plate_step_4": "mdi:circle-slice-2", + "plate_step_5": "mdi:circle-slice-3", + "plate_step_6": "mdi:circle-slice-3", + "plate_step_7": "mdi:circle-slice-4", + "plate_step_8": "mdi:circle-slice-4", + "plate_step_9": "mdi:circle-slice-5", + "plate_step_10": "mdi:circle-slice-5", + "plate_step_11": "mdi:circle-slice-5", + "plate_step_12": "mdi:circle-slice-6", + "plate_step_13": "mdi:circle-slice-6", + "plate_step_14": "mdi:circle-slice-6", + "plate_step_15": "mdi:circle-slice-7", + "plate_step_16": "mdi:circle-slice-7", + "plate_step_17": "mdi:circle-slice-8", + "plate_step_18": "mdi:circle-slice-8", + "plate_step_boost": "mdi:alpha-b-circle-outline" } }, "program_type": { diff --git a/homeassistant/components/miele/sensor.py b/homeassistant/components/miele/sensor.py index d5085ae606f785..ff72b791735e2f 100644 --- a/homeassistant/components/miele/sensor.py +++ b/homeassistant/components/miele/sensor.py @@ -33,6 +33,7 @@ STATE_PROGRAM_PHASE, STATE_STATUS_TAGS, MieleAppliance, + PlatePowerStep, StateDryingStep, StateProgramType, StateStatus, @@ -46,34 +47,6 @@ DISABLED_TEMPERATURE = -32768 -PLATE_POWERS = [ - "0", - "110", - "220", - "1", - "2", - "3", - "4", - "5", - "6", - "7", - "8", - "9", - "10", - "11", - "12", - "13", - "14", - "15", - "16", - "17", - "18", - "117", - "118", - "217", -] - - DEFAULT_PLATE_COUNT = 4 PLATE_COUNT = { @@ -543,8 +516,8 @@ class MieleSensorDefinition: translation_placeholders={"plate_no": str(i)}, zone=i, device_class=SensorDeviceClass.ENUM, - options=PLATE_POWERS, - value_fn=lambda value: value.state_plate_step[0].value_raw, + options=sorted(PlatePowerStep.keys()), + value_fn=lambda value: None, ), ) for i in range(1, 7) @@ -683,12 +656,19 @@ def __init__( def native_value(self) -> StateType: """Return the state of the plate sensor.""" # state_plate_step is [] if all zones are off - plate_power = ( - self.device.state_plate_step[self.entity_description.zone - 1].value_raw + + return ( + PlatePowerStep( + cast( + int, + self.device.state_plate_step[ + self.entity_description.zone - 1 + ].value_raw, + ) + ).name if self.device.state_plate_step - else 0 + else PlatePowerStep.plate_step_0 ) - return str(plate_power) class MieleStatusSensor(MieleSensor): diff --git a/homeassistant/components/miele/strings.json b/homeassistant/components/miele/strings.json index 94aef8d6d3f56c..97035da6d5ff59 100644 --- a/homeassistant/components/miele/strings.json +++ b/homeassistant/components/miele/strings.json @@ -203,30 +203,27 @@ "plate": { "name": "Plate {plate_no}", "state": { - "0": "0", - "110": "Warming", - "220": "[%key:component::miele::entity::sensor::plate::state::110%]", - "1": "1", - "2": "1\u2022", - "3": "2", - "4": "2\u2022", - "5": "3", - "6": "3\u2022", - "7": "4", - "8": "4\u2022", - "9": "5", - "10": "5\u2022", - "11": "6", - "12": "6\u2022", - "13": "7", - "14": "7\u2022", - "15": "8", - "16": "8\u2022", - "17": "9", - "18": "9\u2022", - "117": "Boost", - "118": "[%key:component::miele::entity::sensor::plate::state::117%]", - "217": "[%key:component::miele::entity::sensor::plate::state::117%]" + "power_step_0": "0", + "power_step_warm": "Warming", + "power_step_1": "1", + "power_step_2": "1\u2022", + "power_step_3": "2", + "power_step_4": "2\u2022", + "power_step_5": "3", + "power_step_6": "3\u2022", + "power_step_7": "4", + "power_step_8": "4\u2022", + "power_step_9": "5", + "power_step_10": "5\u2022", + "power_step_11": "6", + "power_step_12": "6\u2022", + "power_step_13": "7", + "power_step_14": "7\u2022", + "power_step_15": "8", + "power_step_16": "8\u2022", + "power_step_17": "9", + "power_step_18": "9\u2022", + "power_step_boost": "Boost" } }, "drying_step": { diff --git a/tests/components/miele/snapshots/test_sensor.ambr b/tests/components/miele/snapshots/test_sensor.ambr index 6984fcc4c502b9..b1691c28b1949d 100644 --- a/tests/components/miele/snapshots/test_sensor.ambr +++ b/tests/components/miele/snapshots/test_sensor.ambr @@ -97,30 +97,26 @@ 'area_id': None, 'capabilities': dict({ 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'config_entry_id': , @@ -158,30 +154,26 @@ 'device_class': 'enum', 'friendly_name': 'Hob with extraction Plate 1', 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'context': , @@ -189,7 +181,7 @@ 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '0', + 'state': 'plate_step_0', }) # --- # name: test_hob_sensor_states[platforms0-hob.json][sensor.hob_with_extraction_plate_2-entry] @@ -199,30 +191,26 @@ 'area_id': None, 'capabilities': dict({ 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'config_entry_id': , @@ -260,30 +248,26 @@ 'device_class': 'enum', 'friendly_name': 'Hob with extraction Plate 2', 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'context': , @@ -291,7 +275,7 @@ 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '110', + 'state': 'plate_step_warming', }) # --- # name: test_hob_sensor_states[platforms0-hob.json][sensor.hob_with_extraction_plate_3-entry] @@ -301,30 +285,26 @@ 'area_id': None, 'capabilities': dict({ 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'config_entry_id': , @@ -362,30 +342,26 @@ 'device_class': 'enum', 'friendly_name': 'Hob with extraction Plate 3', 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'context': , @@ -393,7 +369,7 @@ 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '8', + 'state': 'plate_step_8', }) # --- # name: test_hob_sensor_states[platforms0-hob.json][sensor.hob_with_extraction_plate_4-entry] @@ -403,30 +379,26 @@ 'area_id': None, 'capabilities': dict({ 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'config_entry_id': , @@ -464,30 +436,26 @@ 'device_class': 'enum', 'friendly_name': 'Hob with extraction Plate 4', 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'context': , @@ -495,7 +463,7 @@ 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '15', + 'state': 'plate_step_15', }) # --- # name: test_hob_sensor_states[platforms0-hob.json][sensor.hob_with_extraction_plate_5-entry] @@ -505,30 +473,26 @@ 'area_id': None, 'capabilities': dict({ 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'config_entry_id': , @@ -566,30 +530,26 @@ 'device_class': 'enum', 'friendly_name': 'Hob with extraction Plate 5', 'options': list([ - '0', - '110', - '220', - '1', - '2', - '3', - '4', - '5', - '6', - '7', - '8', - '9', - '10', - '11', - '12', - '13', - '14', - '15', - '16', - '17', - '18', - '117', - '118', - '217', + 'plate_step_0', + 'plate_step_1', + 'plate_step_10', + 'plate_step_11', + 'plate_step_12', + 'plate_step_13', + 'plate_step_15', + 'plate_step_16', + 'plate_step_17', + 'plate_step_18', + 'plate_step_2', + 'plate_step_3', + 'plate_step_4', + 'plate_step_5', + 'plate_step_6', + 'plate_step_7', + 'plate_step_8', + 'plate_step_9', + 'plate_step_boost', + 'plate_step_warming', ]), }), 'context': , @@ -597,7 +557,7 @@ 'last_changed': , 'last_reported': , 'last_updated': , - 'state': '117', + 'state': 'plate_step_boost', }) # --- # name: test_sensor_states[platforms0][sensor.freezer-entry] From ab0ea753e9f3c5c1942f8bec914e53f40236b72b Mon Sep 17 00:00:00 2001 From: Arie Catsman <120491684+catsmanac@users.noreply.github.com> Date: Mon, 23 Jun 2025 22:59:50 +0200 Subject: [PATCH 28/30] Optimize Enphase envoy translation strings. (#147389) optimize Enphase envoy translation strings. --- .../components/enphase_envoy/strings.json | 8 +- .../snapshots/test_diagnostics.ambr | 48 ++-- .../enphase_envoy/snapshots/test_sensor.ambr | 256 +++++++++--------- tests/components/enphase_envoy/test_sensor.py | 12 +- 4 files changed, 162 insertions(+), 162 deletions(-) diff --git a/homeassistant/components/enphase_envoy/strings.json b/homeassistant/components/enphase_envoy/strings.json index 577def459f1173..36319c71bc639d 100644 --- a/homeassistant/components/enphase_envoy/strings.json +++ b/homeassistant/components/enphase_envoy/strings.json @@ -379,7 +379,7 @@ "name": "Aggregated Battery capacity" }, "aggregated_soc": { - "name": "Aggregated battery soc" + "name": "Aggregated battery SOC" }, "dc_voltage": { "name": "DC voltage" @@ -394,13 +394,13 @@ "name": "AC current" }, "lifetime_energy": { - "name": "Lifetime energy produced" + "name": "[%key:component::enphase_envoy::entity::sensor::lifetime_production::name%]" }, "energy_today": { - "name": "Energy produced today" + "name": "[%key:component::enphase_envoy::entity::sensor::daily_production::name%]" }, "energy_produced": { - "name": "Energy produced since previous report" + "name": "Energy production since previous report" }, "max_reported": { "name": "Lifetime maximum power" diff --git a/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr b/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr index 8eb6fcaac37cd2..7ad45ff51f3877 100644 --- a/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr +++ b/tests/components/enphase_envoy/snapshots/test_diagnostics.ambr @@ -606,7 +606,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -620,7 +620,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -647,7 +647,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -658,7 +658,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -723,7 +723,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -734,7 +734,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -1485,7 +1485,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1499,7 +1499,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -1526,7 +1526,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1537,7 +1537,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -1602,7 +1602,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -1613,7 +1613,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -2408,7 +2408,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2422,7 +2422,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -2449,7 +2449,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2460,7 +2460,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -2525,7 +2525,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2536,7 +2536,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -3104,7 +3104,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3118,7 +3118,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -3145,7 +3145,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3156,7 +3156,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -3221,7 +3221,7 @@ 'disabled_by': 'integration', 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -3232,7 +3232,7 @@ }), 'original_device_class': 'energy', 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, diff --git a/tests/components/enphase_envoy/snapshots/test_sensor.ambr b/tests/components/enphase_envoy/snapshots/test_sensor.ambr index 51a596eda188f5..4a9563ce9066b1 100644 --- a/tests/components/enphase_envoy/snapshots/test_sensor.ambr +++ b/tests/components/enphase_envoy/snapshots/test_sensor.ambr @@ -512,7 +512,7 @@ 'state': '33.793', }) # --- -# name: test_sensor[envoy][sensor.inverter_1_energy_produced_since_previous_report-entry] +# name: test_sensor[envoy][sensor.inverter_1_energy_production_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -527,7 +527,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -542,7 +542,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -552,23 +552,23 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy][sensor.inverter_1_energy_produced_since_previous_report-state] +# name: test_sensor[envoy][sensor.inverter_1_energy_production_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'friendly_name': 'Inverter 1 Energy production since previous report', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , 'state': '32.254', }) # --- -# name: test_sensor[envoy][sensor.inverter_1_energy_produced_today-entry] +# name: test_sensor[envoy][sensor.inverter_1_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -583,7 +583,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -598,7 +598,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -608,16 +608,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy][sensor.inverter_1_energy_produced_today-state] +# name: test_sensor[envoy][sensor.inverter_1_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced today', + 'friendly_name': 'Inverter 1 Energy production today', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , @@ -785,7 +785,7 @@ 'state': '2025-06-20T23:06:05+00:00', }) # --- -# name: test_sensor[envoy][sensor.inverter_1_lifetime_energy_produced-entry] +# name: test_sensor[envoy][sensor.inverter_1_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -800,7 +800,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -818,7 +818,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -828,16 +828,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy][sensor.inverter_1_lifetime_energy_produced-state] +# name: test_sensor[envoy][sensor.inverter_1_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'friendly_name': 'Inverter 1 Lifetime energy production', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , @@ -2671,7 +2671,7 @@ 'state': 'unknown', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_since_previous_report-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_production_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -2686,7 +2686,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2701,7 +2701,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -2711,23 +2711,23 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_since_previous_report-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_production_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'friendly_name': 'Inverter 1 Energy production since previous report', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , 'state': 'unknown', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_today-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -2742,7 +2742,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2757,7 +2757,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -2767,16 +2767,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_produced_today-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced today', + 'friendly_name': 'Inverter 1 Energy production today', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , @@ -2944,7 +2944,7 @@ 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_energy_produced-entry] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -2959,7 +2959,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -2977,7 +2977,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -2987,16 +2987,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_energy_produced-state] +# name: test_sensor[envoy_1p_metered][sensor.inverter_1_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'friendly_name': 'Inverter 1 Lifetime energy production', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , @@ -3669,7 +3669,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Aggregated battery soc', + 'original_name': 'Aggregated battery SOC', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -3683,7 +3683,7 @@ StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'battery', - 'friendly_name': 'Envoy 1234 Aggregated battery soc', + 'friendly_name': 'Envoy 1234 Aggregated battery SOC', 'unit_of_measurement': '%', }), 'context': , @@ -8274,7 +8274,7 @@ 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_since_previous_report-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_production_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8289,7 +8289,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8304,7 +8304,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -8314,23 +8314,23 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_since_previous_report-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_production_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'friendly_name': 'Inverter 1 Energy production since previous report', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , 'state': 'unknown', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_today-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8345,7 +8345,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8360,7 +8360,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -8370,16 +8370,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_produced_today-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced today', + 'friendly_name': 'Inverter 1 Energy production today', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , @@ -8547,7 +8547,7 @@ 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_energy_produced-entry] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -8562,7 +8562,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -8580,7 +8580,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -8590,16 +8590,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_energy_produced-state] +# name: test_sensor[envoy_acb_batt][sensor.inverter_1_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'friendly_name': 'Inverter 1 Lifetime energy production', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , @@ -13503,7 +13503,7 @@ 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_since_previous_report-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_production_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13518,7 +13518,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13533,7 +13533,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -13543,23 +13543,23 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_since_previous_report-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_production_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'friendly_name': 'Inverter 1 Energy production since previous report', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , 'state': 'unknown', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_today-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13574,7 +13574,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13589,7 +13589,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -13599,16 +13599,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_produced_today-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced today', + 'friendly_name': 'Inverter 1 Energy production today', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , @@ -13776,7 +13776,7 @@ 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_energy_produced-entry] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -13791,7 +13791,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -13809,7 +13809,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -13819,16 +13819,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_energy_produced-state] +# name: test_sensor[envoy_eu_batt][sensor.inverter_1_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'friendly_name': 'Inverter 1 Lifetime energy production', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , @@ -22642,7 +22642,7 @@ 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_since_previous_report-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_production_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -22657,7 +22657,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22672,7 +22672,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -22682,23 +22682,23 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_since_previous_report-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_production_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'friendly_name': 'Inverter 1 Energy production since previous report', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , 'state': 'unknown', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_today-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -22713,7 +22713,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22728,7 +22728,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -22738,16 +22738,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_produced_today-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced today', + 'friendly_name': 'Inverter 1 Energy production today', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , @@ -22915,7 +22915,7 @@ 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_energy_produced-entry] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -22930,7 +22930,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -22948,7 +22948,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -22958,16 +22958,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_energy_produced-state] +# name: test_sensor[envoy_metered_batt_relay][sensor.inverter_1_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'friendly_name': 'Inverter 1 Lifetime energy production', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , @@ -29106,7 +29106,7 @@ 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_since_previous_report-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_production_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -29121,7 +29121,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -29136,7 +29136,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -29146,23 +29146,23 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_since_previous_report-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_production_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'friendly_name': 'Inverter 1 Energy production since previous report', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , 'state': 'unknown', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_today-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -29177,7 +29177,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -29192,7 +29192,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -29202,16 +29202,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_produced_today-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced today', + 'friendly_name': 'Inverter 1 Energy production today', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , @@ -29379,7 +29379,7 @@ 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_energy_produced-entry] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -29394,7 +29394,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -29412,7 +29412,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -29422,16 +29422,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_energy_produced-state] +# name: test_sensor[envoy_nobatt_metered_3p][sensor.inverter_1_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'friendly_name': 'Inverter 1 Lifetime energy production', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , @@ -30518,7 +30518,7 @@ 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_since_previous_report-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_production_since_previous_report-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -30533,7 +30533,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -30548,7 +30548,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced since previous report', + 'original_name': 'Energy production since previous report', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -30558,23 +30558,23 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_since_previous_report-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_production_since_previous_report-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced since previous report', + 'friendly_name': 'Inverter 1 Energy production since previous report', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_since_previous_report', + 'entity_id': 'sensor.inverter_1_energy_production_since_previous_report', 'last_changed': , 'last_reported': , 'last_updated': , 'state': 'unknown', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_today-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_production_today-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -30589,7 +30589,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -30604,7 +30604,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Energy produced today', + 'original_name': 'Energy production today', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -30614,16 +30614,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_produced_today-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_energy_production_today-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Energy produced today', + 'friendly_name': 'Inverter 1 Energy production today', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_energy_produced_today', + 'entity_id': 'sensor.inverter_1_energy_production_today', 'last_changed': , 'last_reported': , 'last_updated': , @@ -30791,7 +30791,7 @@ 'state': '1970-01-01T00:00:01+00:00', }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_energy_produced-entry] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_energy_production-entry] EntityRegistryEntrySnapshot({ 'aliases': set({ }), @@ -30806,7 +30806,7 @@ 'disabled_by': None, 'domain': 'sensor', 'entity_category': None, - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'has_entity_name': True, 'hidden_by': None, 'icon': None, @@ -30824,7 +30824,7 @@ }), 'original_device_class': , 'original_icon': None, - 'original_name': 'Lifetime energy produced', + 'original_name': 'Lifetime energy production', 'platform': 'enphase_envoy', 'previous_unique_id': None, 'suggested_object_id': None, @@ -30834,16 +30834,16 @@ 'unit_of_measurement': , }) # --- -# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_energy_produced-state] +# name: test_sensor[envoy_tot_cons_metered][sensor.inverter_1_lifetime_energy_production-state] StateSnapshot({ 'attributes': ReadOnlyDict({ 'device_class': 'energy', - 'friendly_name': 'Inverter 1 Lifetime energy produced', + 'friendly_name': 'Inverter 1 Lifetime energy production', 'state_class': , 'unit_of_measurement': , }), 'context': , - 'entity_id': 'sensor.inverter_1_lifetime_energy_produced', + 'entity_id': 'sensor.inverter_1_lifetime_energy_production', 'last_changed': , 'last_reported': , 'last_updated': , diff --git a/tests/components/enphase_envoy/test_sensor.py b/tests/components/enphase_envoy/test_sensor.py index 70bf8c990077ad..a9ee1f370a8fac 100644 --- a/tests/components/enphase_envoy/test_sensor.py +++ b/tests/components/enphase_envoy/test_sensor.py @@ -806,13 +806,13 @@ async def test_sensor_inverter_detailed_data( assert int(temperature.state) == (inverter.temperature) assert ( lifetime_energy := hass.states.get( - f"{entity_base}_{sn}_lifetime_energy_produced" + f"{entity_base}_{sn}_lifetime_energy_production" ) ) assert float(lifetime_energy.state) == (inverter.lifetime_energy / 1000.0) assert ( energy_produced_today := hass.states.get( - f"{entity_base}_{sn}_energy_produced_today" + f"{entity_base}_{sn}_energy_production_today" ) ) assert int(energy_produced_today.state) == (inverter.energy_today) @@ -824,7 +824,7 @@ async def test_sensor_inverter_detailed_data( assert int(last_report_duration.state) == (inverter.last_report_duration) assert ( energy_produced := hass.states.get( - f"{entity_base}_{sn}_energy_produced_since_previous_report" + f"{entity_base}_{sn}_energy_production_since_previous_report" ) ) assert float(energy_produced.state) == (inverter.energy_produced) @@ -871,10 +871,10 @@ async def test_sensor_inverter_disabled_by_integration( "ac_current", "frequency", "temperature", - "lifetime_energy_produced", - "energy_produced_today", + "lifetime_energy_production", + "energy_production_today", "last_report_duration", - "energy_produced_since_previous_report", + "energy_production_since_previous_report", "last_reported", "lifetime_maximum_power", ) From 95abd69cc6de172ba5a5acfb37749532fbf1077d Mon Sep 17 00:00:00 2001 From: Paulus Schoutsen Date: Mon, 23 Jun 2025 17:12:32 -0400 Subject: [PATCH 29/30] Add media class to media player search and play intent (#147097) Co-authored-by: Michael Hansen --- .../components/media_player/intent.py | 23 +++++- tests/components/media_player/test_intent.py | 81 +++++++++++++++++++ 2 files changed, 100 insertions(+), 4 deletions(-) diff --git a/homeassistant/components/media_player/intent.py b/homeassistant/components/media_player/intent.py index c9caa2c4a9141f..be36569457969d 100644 --- a/homeassistant/components/media_player/intent.py +++ b/homeassistant/components/media_player/intent.py @@ -27,7 +27,12 @@ MediaPlayerDeviceClass, SearchMedia, ) -from .const import MediaPlayerEntityFeature, MediaPlayerState +from .const import ( + ATTR_MEDIA_FILTER_CLASSES, + MediaClass, + MediaPlayerEntityFeature, + MediaPlayerState, +) INTENT_MEDIA_PAUSE = "HassMediaPause" INTENT_MEDIA_UNPAUSE = "HassMediaUnpause" @@ -231,6 +236,7 @@ class MediaSearchAndPlayHandler(intent.IntentHandler): intent_type = INTENT_MEDIA_SEARCH_AND_PLAY slot_schema = { vol.Required("search_query"): cv.string, + vol.Optional("media_class"): vol.In([cls.value for cls in MediaClass]), # Optional name/area/floor slots handled by intent matcher vol.Optional("name"): cv.string, vol.Optional("area"): cv.string, @@ -285,14 +291,23 @@ async def async_handle(self, intent_obj: intent.Intent) -> intent.IntentResponse target_entity = match_result.states[0] target_entity_id = target_entity.entity_id + # Get media class if provided + media_class_slot = slots.get("media_class", {}) + media_class_value = media_class_slot.get("value") + + # Build search service data + search_data = {"search_query": search_query} + + # Add media_filter_classes if media_class is provided + if media_class_value: + search_data[ATTR_MEDIA_FILTER_CLASSES] = [media_class_value] + # 1. Search Media try: search_response = await hass.services.async_call( DOMAIN, SERVICE_SEARCH_MEDIA, - { - "search_query": search_query, - }, + search_data, target={ "entity_id": target_entity_id, }, diff --git a/tests/components/media_player/test_intent.py b/tests/components/media_player/test_intent.py index 4b08aa431589ca..d1dc03ed12a524 100644 --- a/tests/components/media_player/test_intent.py +++ b/tests/components/media_player/test_intent.py @@ -792,3 +792,84 @@ async def test_search_and_play_media_player_intent(hass: HomeAssistant) -> None: media_player_intent.INTENT_MEDIA_SEARCH_AND_PLAY, {"search_query": {"value": "error query"}}, ) + + +async def test_search_and_play_media_player_intent_with_media_class( + hass: HomeAssistant, +) -> None: + """Test HassMediaSearchAndPlay intent with media_class parameter.""" + await media_player_intent.async_setup_intents(hass) + + entity_id = f"{DOMAIN}.test_media_player" + attributes = { + ATTR_SUPPORTED_FEATURES: MediaPlayerEntityFeature.SEARCH_MEDIA + | MediaPlayerEntityFeature.PLAY_MEDIA + } + hass.states.async_set(entity_id, STATE_IDLE, attributes=attributes) + + # Test successful search and play with media_class filter + search_result_item = BrowseMedia( + title="Test Album", + media_class=MediaClass.ALBUM, + media_content_type=MediaType.ALBUM, + media_content_id="library/album/123", + can_play=True, + can_expand=False, + ) + + # Mock service calls + search_results = [search_result_item] + search_calls = async_mock_service( + hass, + DOMAIN, + SERVICE_SEARCH_MEDIA, + response={entity_id: SearchMedia(result=search_results)}, + ) + play_calls = async_mock_service(hass, DOMAIN, SERVICE_PLAY_MEDIA) + + response = await intent.async_handle( + hass, + "test", + media_player_intent.INTENT_MEDIA_SEARCH_AND_PLAY, + {"search_query": {"value": "test album"}, "media_class": {"value": "album"}}, + ) + await hass.async_block_till_done() + + assert response.response_type == intent.IntentResponseType.ACTION_DONE + + # Response should contain a "media" slot with the matched item. + assert not response.speech + media = response.speech_slots.get("media") + assert media["title"] == "Test Album" + + assert len(search_calls) == 1 + search_call = search_calls[0] + assert search_call.domain == DOMAIN + assert search_call.service == SERVICE_SEARCH_MEDIA + assert search_call.data == { + "entity_id": entity_id, + "search_query": "test album", + "media_filter_classes": ["album"], + } + + assert len(play_calls) == 1 + play_call = play_calls[0] + assert play_call.domain == DOMAIN + assert play_call.service == SERVICE_PLAY_MEDIA + assert play_call.data == { + "entity_id": entity_id, + "media_content_id": search_result_item.media_content_id, + "media_content_type": search_result_item.media_content_type, + } + + # Test with invalid media_class (should raise validation error) + with pytest.raises(intent.InvalidSlotInfo): + await intent.async_handle( + hass, + "test", + media_player_intent.INTENT_MEDIA_SEARCH_AND_PLAY, + { + "search_query": {"value": "test query"}, + "media_class": {"value": "invalid_class"}, + }, + ) From 646ddf9c2d6144cf70fb6b67eb8ba593aba67f60 Mon Sep 17 00:00:00 2001 From: Manu <4445816+tr4nt0r@users.noreply.github.com> Date: Mon, 23 Jun 2025 23:17:43 +0200 Subject: [PATCH 30/30] Add sensors to ntfy integration (#145262) * Add sensors * small changes * test coverage * changes * update snapshot --- homeassistant/components/ntfy/__init__.py | 11 +- homeassistant/components/ntfy/coordinator.py | 74 ++ homeassistant/components/ntfy/icons.json | 62 + homeassistant/components/ntfy/notify.py | 5 +- homeassistant/components/ntfy/sensor.py | 272 +++++ homeassistant/components/ntfy/strings.json | 82 ++ .../ntfy/snapshots/test_sensor.ambr | 1029 +++++++++++++++++ tests/components/ntfy/test_init.py | 34 + tests/components/ntfy/test_sensor.py | 42 + 9 files changed, 1603 insertions(+), 8 deletions(-) create mode 100644 homeassistant/components/ntfy/coordinator.py create mode 100644 homeassistant/components/ntfy/sensor.py create mode 100644 tests/components/ntfy/snapshots/test_sensor.ambr create mode 100644 tests/components/ntfy/test_sensor.py diff --git a/homeassistant/components/ntfy/__init__.py b/homeassistant/components/ntfy/__init__.py index cd9c35ca4e6020..72dbb4d2afb0bf 100644 --- a/homeassistant/components/ntfy/__init__.py +++ b/homeassistant/components/ntfy/__init__.py @@ -12,19 +12,16 @@ NtfyUnauthorizedAuthenticationError, ) -from homeassistant.config_entries import ConfigEntry from homeassistant.const import CONF_TOKEN, CONF_URL, CONF_VERIFY_SSL, Platform from homeassistant.core import HomeAssistant from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady from homeassistant.helpers.aiohttp_client import async_get_clientsession from .const import DOMAIN +from .coordinator import NtfyConfigEntry, NtfyDataUpdateCoordinator _LOGGER = logging.getLogger(__name__) -PLATFORMS: list[Platform] = [Platform.NOTIFY] - - -type NtfyConfigEntry = ConfigEntry[Ntfy] +PLATFORMS: list[Platform] = [Platform.NOTIFY, Platform.SENSOR] async def async_setup_entry(hass: HomeAssistant, entry: NtfyConfigEntry) -> bool: @@ -59,7 +56,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: NtfyConfigEntry) -> bool translation_key="timeout_error", ) from e - entry.runtime_data = ntfy + coordinator = NtfyDataUpdateCoordinator(hass, entry, ntfy) + await coordinator.async_config_entry_first_refresh() + entry.runtime_data = coordinator await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS) diff --git a/homeassistant/components/ntfy/coordinator.py b/homeassistant/components/ntfy/coordinator.py new file mode 100644 index 00000000000000..a52f1b06f41ad3 --- /dev/null +++ b/homeassistant/components/ntfy/coordinator.py @@ -0,0 +1,74 @@ +"""DataUpdateCoordinator for ntfy integration.""" + +from __future__ import annotations + +from datetime import timedelta +import logging + +from aiontfy import Account as NtfyAccount, Ntfy +from aiontfy.exceptions import ( + NtfyConnectionError, + NtfyHTTPError, + NtfyTimeoutError, + NtfyUnauthorizedAuthenticationError, +) + +from homeassistant.config_entries import ConfigEntry +from homeassistant.core import HomeAssistant +from homeassistant.exceptions import ConfigEntryAuthFailed +from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed + +from .const import DOMAIN + +_LOGGER = logging.getLogger(__name__) + +type NtfyConfigEntry = ConfigEntry[NtfyDataUpdateCoordinator] + + +class NtfyDataUpdateCoordinator(DataUpdateCoordinator[NtfyAccount]): + """Ntfy data update coordinator.""" + + config_entry: NtfyConfigEntry + + def __init__( + self, hass: HomeAssistant, config_entry: NtfyConfigEntry, ntfy: Ntfy + ) -> None: + """Initialize the ntfy data update coordinator.""" + super().__init__( + hass, + _LOGGER, + config_entry=config_entry, + name=DOMAIN, + update_interval=timedelta(minutes=15), + ) + + self.ntfy = ntfy + + async def _async_update_data(self) -> NtfyAccount: + """Fetch account data from ntfy.""" + + try: + return await self.ntfy.account() + except NtfyUnauthorizedAuthenticationError as e: + raise ConfigEntryAuthFailed( + translation_domain=DOMAIN, + translation_key="authentication_error", + ) from e + except NtfyHTTPError as e: + _LOGGER.debug("Error %s: %s [%s]", e.code, e.error, e.link) + raise UpdateFailed( + translation_domain=DOMAIN, + translation_key="server_error", + translation_placeholders={"error_msg": str(e.error)}, + ) from e + except NtfyConnectionError as e: + _LOGGER.debug("Error", exc_info=True) + raise UpdateFailed( + translation_domain=DOMAIN, + translation_key="connection_error", + ) from e + except NtfyTimeoutError as e: + raise UpdateFailed( + translation_domain=DOMAIN, + translation_key="timeout_error", + ) from e diff --git a/homeassistant/components/ntfy/icons.json b/homeassistant/components/ntfy/icons.json index 9fe617880afd6e..66489413b5b38a 100644 --- a/homeassistant/components/ntfy/icons.json +++ b/homeassistant/components/ntfy/icons.json @@ -4,6 +4,68 @@ "publish": { "default": "mdi:console-line" } + }, + "sensor": { + "messages": { + "default": "mdi:message-arrow-right-outline" + }, + "messages_remaining": { + "default": "mdi:message-plus-outline" + }, + "messages_limit": { + "default": "mdi:message-alert-outline" + }, + "messages_expiry_duration": { + "default": "mdi:message-text-clock" + }, + "emails": { + "default": "mdi:email-arrow-right-outline" + }, + "emails_remaining": { + "default": "mdi:email-plus-outline" + }, + "emails_limit": { + "default": "mdi:email-alert-outline" + }, + "calls": { + "default": "mdi:phone-outgoing" + }, + "calls_remaining": { + "default": "mdi:phone-plus" + }, + "calls_limit": { + "default": "mdi:phone-alert" + }, + "reservations": { + "default": "mdi:lock" + }, + "reservations_remaining": { + "default": "mdi:lock-plus" + }, + "reservations_limit": { + "default": "mdi:lock-alert" + }, + "attachment_total_size": { + "default": "mdi:database-arrow-right" + }, + "attachment_total_size_remaining": { + "default": "mdi:database-plus" + }, + "attachment_total_size_limit": { + "default": "mdi:database-alert" + }, + "attachment_expiry_duration": { + "default": "mdi:cloud-clock" + }, + "attachment_file_size": { + "default": "mdi:file-alert" + }, + "attachment_bandwidth": { + "default": "mdi:cloud-upload" + }, + "tier": { + "default": "mdi:star" + } } } } diff --git a/homeassistant/components/ntfy/notify.py b/homeassistant/components/ntfy/notify.py index 7328a1533c233f..e10e64caf23e8e 100644 --- a/homeassistant/components/ntfy/notify.py +++ b/homeassistant/components/ntfy/notify.py @@ -22,8 +22,8 @@ from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback -from . import NtfyConfigEntry from .const import CONF_TOPIC, DOMAIN +from .coordinator import NtfyConfigEntry PARALLEL_UPDATES = 0 @@ -69,9 +69,10 @@ def __init__( name=subentry.data.get(CONF_NAME, self.topic), configuration_url=URL(config_entry.data[CONF_URL]) / self.topic, identifiers={(DOMAIN, f"{config_entry.entry_id}_{subentry.subentry_id}")}, + via_device=(DOMAIN, config_entry.entry_id), ) self.config_entry = config_entry - self.ntfy = config_entry.runtime_data + self.ntfy = config_entry.runtime_data.ntfy async def async_send_message(self, message: str, title: str | None = None) -> None: """Publish a message to a topic.""" diff --git a/homeassistant/components/ntfy/sensor.py b/homeassistant/components/ntfy/sensor.py new file mode 100644 index 00000000000000..0180d9fce72b53 --- /dev/null +++ b/homeassistant/components/ntfy/sensor.py @@ -0,0 +1,272 @@ +"""Sensor platform for ntfy integration.""" + +from __future__ import annotations + +from collections.abc import Callable +from dataclasses import dataclass +from enum import StrEnum + +from aiontfy import Account as NtfyAccount +from yarl import URL + +from homeassistant.components.sensor import ( + SensorDeviceClass, + SensorEntity, + SensorEntityDescription, +) +from homeassistant.const import CONF_URL, EntityCategory, UnitOfInformation, UnitOfTime +from homeassistant.core import HomeAssistant +from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo +from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback +from homeassistant.helpers.typing import StateType +from homeassistant.helpers.update_coordinator import CoordinatorEntity + +from .const import DOMAIN +from .coordinator import NtfyConfigEntry, NtfyDataUpdateCoordinator + +PARALLEL_UPDATES = 0 + + +@dataclass(kw_only=True, frozen=True) +class NtfySensorEntityDescription(SensorEntityDescription): + """Ntfy Sensor Description.""" + + value_fn: Callable[[NtfyAccount], StateType] + + +class NtfySensor(StrEnum): + """Ntfy sensors.""" + + MESSAGES = "messages" + MESSAGES_REMAINING = "messages_remaining" + MESSAGES_LIMIT = "messages_limit" + MESSAGES_EXPIRY_DURATION = "messages_expiry_duration" + EMAILS = "emails" + EMAILS_REMAINING = "emails_remaining" + EMAILS_LIMIT = "emails_limit" + CALLS = "calls" + CALLS_REMAINING = "calls_remaining" + CALLS_LIMIT = "calls_limit" + RESERVATIONS = "reservations" + RESERVATIONS_REMAINING = "reservations_remaining" + RESERVATIONS_LIMIT = "reservations_limit" + ATTACHMENT_TOTAL_SIZE = "attachment_total_size" + ATTACHMENT_TOTAL_SIZE_REMAINING = "attachment_total_size_remaining" + ATTACHMENT_TOTAL_SIZE_LIMIT = "attachment_total_size_limit" + ATTACHMENT_EXPIRY_DURATION = "attachment_expiry_duration" + ATTACHMENT_BANDWIDTH = "attachment_bandwidth" + ATTACHMENT_FILE_SIZE = "attachment_file_size" + TIER = "tier" + + +SENSOR_DESCRIPTIONS: tuple[NtfySensorEntityDescription, ...] = ( + NtfySensorEntityDescription( + key=NtfySensor.MESSAGES, + translation_key=NtfySensor.MESSAGES, + value_fn=lambda account: account.stats.messages, + ), + NtfySensorEntityDescription( + key=NtfySensor.MESSAGES_REMAINING, + translation_key=NtfySensor.MESSAGES_REMAINING, + value_fn=lambda account: account.stats.messages_remaining, + entity_registry_enabled_default=False, + ), + NtfySensorEntityDescription( + key=NtfySensor.MESSAGES_LIMIT, + translation_key=NtfySensor.MESSAGES_LIMIT, + value_fn=lambda account: account.limits.messages if account.limits else None, + entity_category=EntityCategory.DIAGNOSTIC, + ), + NtfySensorEntityDescription( + key=NtfySensor.MESSAGES_EXPIRY_DURATION, + translation_key=NtfySensor.MESSAGES_EXPIRY_DURATION, + value_fn=( + lambda account: account.limits.messages_expiry_duration + if account.limits + else None + ), + entity_category=EntityCategory.DIAGNOSTIC, + device_class=SensorDeviceClass.DURATION, + native_unit_of_measurement=UnitOfTime.SECONDS, + suggested_unit_of_measurement=UnitOfTime.HOURS, + ), + NtfySensorEntityDescription( + key=NtfySensor.EMAILS, + translation_key=NtfySensor.EMAILS, + value_fn=lambda account: account.stats.emails, + ), + NtfySensorEntityDescription( + key=NtfySensor.EMAILS_REMAINING, + translation_key=NtfySensor.EMAILS_REMAINING, + value_fn=lambda account: account.stats.emails_remaining, + entity_registry_enabled_default=False, + ), + NtfySensorEntityDescription( + key=NtfySensor.EMAILS_LIMIT, + translation_key=NtfySensor.EMAILS_LIMIT, + value_fn=lambda account: account.limits.emails if account.limits else None, + entity_category=EntityCategory.DIAGNOSTIC, + ), + NtfySensorEntityDescription( + key=NtfySensor.CALLS, + translation_key=NtfySensor.CALLS, + value_fn=lambda account: account.stats.calls, + ), + NtfySensorEntityDescription( + key=NtfySensor.CALLS_REMAINING, + translation_key=NtfySensor.CALLS_REMAINING, + value_fn=lambda account: account.stats.calls_remaining, + entity_registry_enabled_default=False, + ), + NtfySensorEntityDescription( + key=NtfySensor.CALLS_LIMIT, + translation_key=NtfySensor.CALLS_LIMIT, + value_fn=lambda account: account.limits.calls if account.limits else None, + entity_category=EntityCategory.DIAGNOSTIC, + ), + NtfySensorEntityDescription( + key=NtfySensor.RESERVATIONS, + translation_key=NtfySensor.RESERVATIONS, + value_fn=lambda account: account.stats.reservations, + ), + NtfySensorEntityDescription( + key=NtfySensor.RESERVATIONS_REMAINING, + translation_key=NtfySensor.RESERVATIONS_REMAINING, + value_fn=lambda account: account.stats.reservations_remaining, + entity_registry_enabled_default=False, + ), + NtfySensorEntityDescription( + key=NtfySensor.RESERVATIONS_LIMIT, + translation_key=NtfySensor.RESERVATIONS_LIMIT, + value_fn=( + lambda account: account.limits.reservations if account.limits else None + ), + entity_category=EntityCategory.DIAGNOSTIC, + ), + NtfySensorEntityDescription( + key=NtfySensor.ATTACHMENT_EXPIRY_DURATION, + translation_key=NtfySensor.ATTACHMENT_EXPIRY_DURATION, + value_fn=( + lambda account: account.limits.attachment_expiry_duration + if account.limits + else None + ), + entity_category=EntityCategory.DIAGNOSTIC, + device_class=SensorDeviceClass.DURATION, + native_unit_of_measurement=UnitOfTime.SECONDS, + suggested_unit_of_measurement=UnitOfTime.HOURS, + ), + NtfySensorEntityDescription( + key=NtfySensor.ATTACHMENT_TOTAL_SIZE, + translation_key=NtfySensor.ATTACHMENT_TOTAL_SIZE, + value_fn=lambda account: account.stats.attachment_total_size, + device_class=SensorDeviceClass.DATA_SIZE, + native_unit_of_measurement=UnitOfInformation.BYTES, + suggested_unit_of_measurement=UnitOfInformation.MEBIBYTES, + suggested_display_precision=0, + ), + NtfySensorEntityDescription( + key=NtfySensor.ATTACHMENT_TOTAL_SIZE_REMAINING, + translation_key=NtfySensor.ATTACHMENT_TOTAL_SIZE_REMAINING, + value_fn=lambda account: account.stats.attachment_total_size_remaining, + device_class=SensorDeviceClass.DATA_SIZE, + native_unit_of_measurement=UnitOfInformation.BYTES, + suggested_unit_of_measurement=UnitOfInformation.MEBIBYTES, + suggested_display_precision=0, + entity_registry_enabled_default=False, + ), + NtfySensorEntityDescription( + key=NtfySensor.ATTACHMENT_TOTAL_SIZE_LIMIT, + translation_key=NtfySensor.ATTACHMENT_TOTAL_SIZE_LIMIT, + value_fn=( + lambda account: account.limits.attachment_total_size + if account.limits + else None + ), + entity_category=EntityCategory.DIAGNOSTIC, + device_class=SensorDeviceClass.DATA_SIZE, + native_unit_of_measurement=UnitOfInformation.BYTES, + suggested_unit_of_measurement=UnitOfInformation.MEBIBYTES, + suggested_display_precision=0, + ), + NtfySensorEntityDescription( + key=NtfySensor.ATTACHMENT_FILE_SIZE, + translation_key=NtfySensor.ATTACHMENT_FILE_SIZE, + value_fn=( + lambda account: account.limits.attachment_file_size + if account.limits + else None + ), + entity_category=EntityCategory.DIAGNOSTIC, + device_class=SensorDeviceClass.DATA_SIZE, + native_unit_of_measurement=UnitOfInformation.BYTES, + suggested_unit_of_measurement=UnitOfInformation.MEBIBYTES, + suggested_display_precision=0, + ), + NtfySensorEntityDescription( + key=NtfySensor.ATTACHMENT_BANDWIDTH, + translation_key=NtfySensor.ATTACHMENT_BANDWIDTH, + value_fn=( + lambda account: account.limits.attachment_bandwidth + if account.limits + else None + ), + entity_category=EntityCategory.DIAGNOSTIC, + device_class=SensorDeviceClass.DATA_SIZE, + native_unit_of_measurement=UnitOfInformation.BYTES, + suggested_unit_of_measurement=UnitOfInformation.MEBIBYTES, + suggested_display_precision=0, + ), + NtfySensorEntityDescription( + key=NtfySensor.TIER, + translation_key=NtfySensor.TIER, + value_fn=lambda account: account.tier.name if account.tier else "free", + entity_category=EntityCategory.DIAGNOSTIC, + entity_registry_enabled_default=False, + ), +) + + +async def async_setup_entry( + hass: HomeAssistant, + config_entry: NtfyConfigEntry, + async_add_entities: AddConfigEntryEntitiesCallback, +) -> None: + """Set up the sensor platform.""" + coordinator = config_entry.runtime_data + async_add_entities( + NtfySensorEntity(coordinator, description) + for description in SENSOR_DESCRIPTIONS + ) + + +class NtfySensorEntity(CoordinatorEntity[NtfyDataUpdateCoordinator], SensorEntity): + """Representation of a ntfy sensor entity.""" + + entity_description: NtfySensorEntityDescription + coordinator: NtfyDataUpdateCoordinator + + _attr_has_entity_name = True + + def __init__( + self, + coordinator: NtfyDataUpdateCoordinator, + description: NtfySensorEntityDescription, + ) -> None: + """Initialize a sensor entity.""" + super().__init__(coordinator) + self.entity_description = description + self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{description.key}" + self._attr_device_info = DeviceInfo( + entry_type=DeviceEntryType.SERVICE, + manufacturer="ntfy LLC", + model="ntfy", + configuration_url=URL(coordinator.config_entry.data[CONF_URL]) / "app", + identifiers={(DOMAIN, coordinator.config_entry.entry_id)}, + ) + + @property + def native_value(self) -> StateType: + """Return the state of the sensor.""" + + return self.entity_description.value_fn(self.coordinator.data) diff --git a/homeassistant/components/ntfy/strings.json b/homeassistant/components/ntfy/strings.json index cef662d6f2f76d..08a0a20a30a1d6 100644 --- a/homeassistant/components/ntfy/strings.json +++ b/homeassistant/components/ntfy/strings.json @@ -120,6 +120,88 @@ } } }, + "entity": { + "sensor": { + "messages": { + "name": "Messages published", + "unit_of_measurement": "messages" + }, + "messages_remaining": { + "name": "Messages remaining", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::messages::unit_of_measurement%]" + }, + "messages_limit": { + "name": "Messages usage limit", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::messages::unit_of_measurement%]" + }, + "messages_expiry_duration": { + "name": "Messages expiry duration" + }, + "emails": { + "name": "Emails sent", + "unit_of_measurement": "emails" + }, + "emails_remaining": { + "name": "Emails remaining", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::emails::unit_of_measurement%]" + }, + "emails_limit": { + "name": "Email usage limit", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::emails::unit_of_measurement%]" + }, + "calls": { + "name": "Phone calls made", + "unit_of_measurement": "calls" + }, + "calls_remaining": { + "name": "Phone calls remaining", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::calls::unit_of_measurement%]" + }, + "calls_limit": { + "name": "Phone calls usage limit", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::calls::unit_of_measurement%]" + }, + "reservations": { + "name": "Reserved topics", + "unit_of_measurement": "topics" + }, + "reservations_remaining": { + "name": "Reserved topics remaining", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::reservations::unit_of_measurement%]" + }, + "reservations_limit": { + "name": "Reserved topics limit", + "unit_of_measurement": "[%key:component::ntfy::entity::sensor::reservations::unit_of_measurement%]" + }, + "attachment_total_size": { + "name": "Attachment storage" + }, + "attachment_total_size_remaining": { + "name": "Attachment storage remaining" + }, + "attachment_total_size_limit": { + "name": "Attachment storage limit" + }, + "attachment_expiry_duration": { + "name": "Attachment expiry duration" + }, + "attachment_file_size": { + "name": "Attachment file size limit" + }, + "attachment_bandwidth": { + "name": "Attachment bandwidth limit" + }, + "tier": { + "name": "Subscription tier", + "state": { + "free": "Free", + "supporter": "Supporter", + "pro": "Pro", + "business": "Business" + } + } + } + }, "exceptions": { "publish_failed_request_error": { "message": "Failed to publish notification: {error_msg}" diff --git a/tests/components/ntfy/snapshots/test_sensor.ambr b/tests/components/ntfy/snapshots/test_sensor.ambr new file mode 100644 index 00000000000000..fd0dd3c4bd410a --- /dev/null +++ b/tests/components/ntfy/snapshots/test_sensor.ambr @@ -0,0 +1,1029 @@ +# serializer version: 1 +# name: test_setup[sensor.ntfy_sh_attachment_bandwidth_limit-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_attachment_bandwidth_limit', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Attachment bandwidth limit', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_attachment_bandwidth', + 'unit_of_measurement': , + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_bandwidth_limit-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'data_size', + 'friendly_name': 'ntfy.sh Attachment bandwidth limit', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_attachment_bandwidth_limit', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1024.0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_expiry_duration-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_attachment_expiry_duration', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Attachment expiry duration', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_attachment_expiry_duration', + 'unit_of_measurement': , + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_expiry_duration-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'duration', + 'friendly_name': 'ntfy.sh Attachment expiry duration', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_attachment_expiry_duration', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '6.0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_file_size_limit-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_attachment_file_size_limit', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Attachment file size limit', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_attachment_file_size', + 'unit_of_measurement': , + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_file_size_limit-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'data_size', + 'friendly_name': 'ntfy.sh Attachment file size limit', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_attachment_file_size_limit', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '15.0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_storage-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_attachment_storage', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Attachment storage', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_attachment_total_size', + 'unit_of_measurement': , + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_storage-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'data_size', + 'friendly_name': 'ntfy.sh Attachment storage', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_attachment_storage', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0.0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_storage_limit-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_attachment_storage_limit', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Attachment storage limit', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_attachment_total_size_limit', + 'unit_of_measurement': , + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_storage_limit-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'data_size', + 'friendly_name': 'ntfy.sh Attachment storage limit', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_attachment_storage_limit', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '100.0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_storage_remaining-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_attachment_storage_remaining', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 0, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Attachment storage remaining', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_attachment_total_size_remaining', + 'unit_of_measurement': , + }) +# --- +# name: test_setup[sensor.ntfy_sh_attachment_storage_remaining-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'data_size', + 'friendly_name': 'ntfy.sh Attachment storage remaining', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_attachment_storage_remaining', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '100.0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_email_usage_limit-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_email_usage_limit', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Email usage limit', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_emails_limit', + 'unit_of_measurement': 'emails', + }) +# --- +# name: test_setup[sensor.ntfy_sh_email_usage_limit-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Email usage limit', + 'unit_of_measurement': 'emails', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_email_usage_limit', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '20', + }) +# --- +# name: test_setup[sensor.ntfy_sh_emails_remaining-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_emails_remaining', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Emails remaining', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_emails_remaining', + 'unit_of_measurement': 'emails', + }) +# --- +# name: test_setup[sensor.ntfy_sh_emails_remaining-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Emails remaining', + 'unit_of_measurement': 'emails', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_emails_remaining', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '20', + }) +# --- +# name: test_setup[sensor.ntfy_sh_emails_sent-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_emails_sent', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Emails sent', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_emails', + 'unit_of_measurement': 'emails', + }) +# --- +# name: test_setup[sensor.ntfy_sh_emails_sent-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Emails sent', + 'unit_of_measurement': 'emails', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_emails_sent', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_expiry_duration-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_messages_expiry_duration', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + 'sensor': dict({ + 'suggested_display_precision': 2, + }), + 'sensor.private': dict({ + 'suggested_unit_of_measurement': , + }), + }), + 'original_device_class': , + 'original_icon': None, + 'original_name': 'Messages expiry duration', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_messages_expiry_duration', + 'unit_of_measurement': , + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_expiry_duration-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'device_class': 'duration', + 'friendly_name': 'ntfy.sh Messages expiry duration', + 'unit_of_measurement': , + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_messages_expiry_duration', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '12.0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_published-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_messages_published', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Messages published', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_messages', + 'unit_of_measurement': 'messages', + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_published-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Messages published', + 'unit_of_measurement': 'messages', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_messages_published', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '10', + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_remaining-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_messages_remaining', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Messages remaining', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_messages_remaining', + 'unit_of_measurement': 'messages', + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_remaining-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Messages remaining', + 'unit_of_measurement': 'messages', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_messages_remaining', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '4990', + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_usage_limit-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_messages_usage_limit', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Messages usage limit', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_messages_limit', + 'unit_of_measurement': 'messages', + }) +# --- +# name: test_setup[sensor.ntfy_sh_messages_usage_limit-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Messages usage limit', + 'unit_of_measurement': 'messages', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_messages_usage_limit', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '5000', + }) +# --- +# name: test_setup[sensor.ntfy_sh_phone_calls_made-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_phone_calls_made', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Phone calls made', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_calls', + 'unit_of_measurement': 'calls', + }) +# --- +# name: test_setup[sensor.ntfy_sh_phone_calls_made-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Phone calls made', + 'unit_of_measurement': 'calls', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_phone_calls_made', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_phone_calls_remaining-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_phone_calls_remaining', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Phone calls remaining', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_calls_remaining', + 'unit_of_measurement': 'calls', + }) +# --- +# name: test_setup[sensor.ntfy_sh_phone_calls_remaining-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Phone calls remaining', + 'unit_of_measurement': 'calls', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_phone_calls_remaining', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_phone_calls_usage_limit-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_phone_calls_usage_limit', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Phone calls usage limit', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_calls_limit', + 'unit_of_measurement': 'calls', + }) +# --- +# name: test_setup[sensor.ntfy_sh_phone_calls_usage_limit-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Phone calls usage limit', + 'unit_of_measurement': 'calls', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_phone_calls_usage_limit', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '0', + }) +# --- +# name: test_setup[sensor.ntfy_sh_reserved_topics-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_reserved_topics', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Reserved topics', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_reservations', + 'unit_of_measurement': 'topics', + }) +# --- +# name: test_setup[sensor.ntfy_sh_reserved_topics-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Reserved topics', + 'unit_of_measurement': 'topics', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_reserved_topics', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '1', + }) +# --- +# name: test_setup[sensor.ntfy_sh_reserved_topics_limit-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_reserved_topics_limit', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Reserved topics limit', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_reservations_limit', + 'unit_of_measurement': 'topics', + }) +# --- +# name: test_setup[sensor.ntfy_sh_reserved_topics_limit-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Reserved topics limit', + 'unit_of_measurement': 'topics', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_reserved_topics_limit', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '3', + }) +# --- +# name: test_setup[sensor.ntfy_sh_reserved_topics_remaining-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': None, + 'entity_id': 'sensor.ntfy_sh_reserved_topics_remaining', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Reserved topics remaining', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_reservations_remaining', + 'unit_of_measurement': 'topics', + }) +# --- +# name: test_setup[sensor.ntfy_sh_reserved_topics_remaining-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Reserved topics remaining', + 'unit_of_measurement': 'topics', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_reserved_topics_remaining', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': '2', + }) +# --- +# name: test_setup[sensor.ntfy_sh_subscription_tier-entry] + EntityRegistryEntrySnapshot({ + 'aliases': set({ + }), + 'area_id': None, + 'capabilities': None, + 'config_entry_id': , + 'config_subentry_id': , + 'device_class': None, + 'device_id': , + 'disabled_by': None, + 'domain': 'sensor', + 'entity_category': , + 'entity_id': 'sensor.ntfy_sh_subscription_tier', + 'has_entity_name': True, + 'hidden_by': None, + 'icon': None, + 'id': , + 'labels': set({ + }), + 'name': None, + 'options': dict({ + }), + 'original_device_class': None, + 'original_icon': None, + 'original_name': 'Subscription tier', + 'platform': 'ntfy', + 'previous_unique_id': None, + 'suggested_object_id': None, + 'supported_features': 0, + 'translation_key': , + 'unique_id': '123456789_tier', + 'unit_of_measurement': None, + }) +# --- +# name: test_setup[sensor.ntfy_sh_subscription_tier-state] + StateSnapshot({ + 'attributes': ReadOnlyDict({ + 'friendly_name': 'ntfy.sh Subscription tier', + }), + 'context': , + 'entity_id': 'sensor.ntfy_sh_subscription_tier', + 'last_changed': , + 'last_reported': , + 'last_updated': , + 'state': 'starter', + }) +# --- diff --git a/tests/components/ntfy/test_init.py b/tests/components/ntfy/test_init.py index b80badd8581d6b..b5b73d1272c60f 100644 --- a/tests/components/ntfy/test_init.py +++ b/tests/components/ntfy/test_init.py @@ -65,3 +65,37 @@ async def test_config_entry_not_ready( await hass.async_block_till_done() assert config_entry.state is state + + +@pytest.mark.parametrize( + ("exception", "state"), + [ + ( + NtfyUnauthorizedAuthenticationError( + 40101, + 401, + "unauthorized", + "https://ntfy.sh/docs/publish/#authentication", + ), + ConfigEntryState.SETUP_ERROR, + ), + (NtfyHTTPError(418001, 418, "I'm a teapot", ""), ConfigEntryState.SETUP_RETRY), + (NtfyConnectionError, ConfigEntryState.SETUP_RETRY), + (NtfyTimeoutError, ConfigEntryState.SETUP_RETRY), + ], +) +async def test_coordinator_update_exceptions( + hass: HomeAssistant, + config_entry: MockConfigEntry, + mock_aiontfy: AsyncMock, + exception: Exception, + state: ConfigEntryState, +) -> None: + """Test config entry not ready from update failed in _async_update_data.""" + mock_aiontfy.account.side_effect = [None, exception] + + config_entry.add_to_hass(hass) + await hass.config_entries.async_setup(config_entry.entry_id) + await hass.async_block_till_done() + + assert config_entry.state is state diff --git a/tests/components/ntfy/test_sensor.py b/tests/components/ntfy/test_sensor.py new file mode 100644 index 00000000000000..4685cf946ee3ca --- /dev/null +++ b/tests/components/ntfy/test_sensor.py @@ -0,0 +1,42 @@ +"""Tests for the ntfy sensor platform.""" + +from collections.abc import Generator +from unittest.mock import patch + +import pytest +from syrupy.assertion import SnapshotAssertion + +from homeassistant.config_entries import ConfigEntryState +from homeassistant.const import Platform +from homeassistant.core import HomeAssistant +from homeassistant.helpers import entity_registry as er + +from tests.common import MockConfigEntry, snapshot_platform + + +@pytest.fixture(autouse=True) +def sensor_only() -> Generator[None]: + """Enable only the sensor platform.""" + with patch( + "homeassistant.components.ntfy.PLATFORMS", + [Platform.SENSOR], + ): + yield + + +@pytest.mark.usefixtures("mock_aiontfy", "entity_registry_enabled_by_default") +async def test_setup( + hass: HomeAssistant, + config_entry: MockConfigEntry, + snapshot: SnapshotAssertion, + entity_registry: er.EntityRegistry, +) -> None: + """Snapshot test states of sensor platform.""" + + config_entry.add_to_hass(hass) + await hass.config_entries.async_setup(config_entry.entry_id) + await hass.async_block_till_done() + + assert config_entry.state is ConfigEntryState.LOADED + + await snapshot_platform(hass, entity_registry, snapshot, config_entry.entry_id)