Feature/add async step user (#14)

* add async_step_user to support kits that don't discover powersensor

* Virtual household will add only when mains is present (consumption only if mains only and consumption and production if solar/mains)--no virtual household with solar only

* Added a lock/status to prevent double firing of solar

* Added a lock/status to prevent double firing of mains

---------

Authored-by: Lake Bookman <lbookman@dius.com.au>

Author: jmattsson

custom_components/powersensor/__init__.py

@@ -85,7 +85,7 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     if entry.version == 1:
         # Move device info into subkey, add with_solar key
         devices = { **entry.data }
-        new_data = { 'devices': devices, 'with_solar': False, 'roles': {} }
+        new_data = { 'devices': devices, 'with_solar': False, 'with_mains': False, 'roles': {} }
         hass.config_entries.async_update_entry(entry, data=new_data, version=2, minor_version=1)
 
     _LOGGER.debug("Upgrading config to %s.%s", entry.version, entry.minor_version)

custom_components/powersensor/config_flow.py

@@ -91,35 +91,14 @@ async def async_step_reconfigure(self, user_input: dict | None = None)->FlowResu
             }
         )
 
-    async def async_step_zeroconf(
-        self, discovery_info: zeroconf.ZeroconfServiceInfo
-    ) -> ConfigFlowResult:
-        """Handle zeroconf discovery."""
-        host = discovery_info.host
-        port = discovery_info.port or DEFAULT_PORT
-        display_name = _extract_device_name(discovery_info) or ""
-        properties = discovery_info.properties or {}
-        mac = None
-        if "id" in properties:
-            mac = properties["id"].strip()
-
-        plug_data = {'host' : host,'port' :  port,  'display_name' : display_name,
-                     'mac': mac, 'name': discovery_info.name}
-
+    async def _common_setup(self):
         if DOMAIN not in self.hass.data:
             self.hass.data[DOMAIN] = {}
 
         discovered_plugs_key = "discovered_plugs"
         if discovered_plugs_key not in self.hass.data[DOMAIN]:
             self.hass.data[DOMAIN][discovered_plugs_key] = {}
 
-        if mac in self.hass.data[DOMAIN][discovered_plugs_key].keys():
-            _LOGGER.debug("Mac found existing in data!")
-        else:
-            self.hass.data[DOMAIN][discovered_plugs_key][mac] = plug_data
-
-
-
         # register a unique id for the single power sensor entry
         await self.async_set_unique_id(DOMAIN)
 
@@ -128,19 +107,48 @@ async def async_step_zeroconf(
             _LOGGER.warning("Aborting - found existing entry!")
             return self.async_abort(reason="already_configured")
 
+
         display_name = f"⚡ Powersensor 🔌\n"
         self.context.update({
             "title_placeholders": {
                 "name": display_name
             }
         })
-        return await self.async_step_discovery_confirm()
 
-    async def async_step_discovery_confirm(
+    async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
+        """Handle zeroconf discovery."""
+        await self._common_setup()
+        return await self.async_step_manual_confirm()
+
+
+    async def async_step_zeroconf(
+        self, discovery_info: zeroconf.ZeroconfServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle zeroconf discovery."""
+        await self._common_setup()
+        discovered_plugs_key = "discovered_plugs"
+        host = discovery_info.host
+        port = discovery_info.port or DEFAULT_PORT
+        display_name = _extract_device_name(discovery_info) or ""
+        properties = discovery_info.properties or {}
+        mac = None
+        if "id" in properties:
+            mac = properties["id"].strip()
+
+        plug_data = {'host' : host,'port' :  port,  'display_name' : display_name,
+                     'mac': mac, 'name': discovery_info.name}
+
+
+        if mac in self.hass.data[DOMAIN][discovered_plugs_key].keys():
+            _LOGGER.debug("Mac found existing in data!")
+        else:
+            self.hass.data[DOMAIN][discovered_plugs_key][mac] = plug_data
 
-        """Confirm discovery."""
+        return await self.async_step_discovery_confirm()
+
+    async def async_step_confirm(self, step_id :str, user_input: dict[str, Any] | None = None):
         if user_input is not None:
             _LOGGER.debug(self.hass.data[DOMAIN]["discovered_plugs"])
             return self.async_create_entry(
@@ -151,4 +159,16 @@ async def async_step_discovery_confirm(
                     'roles': {},
                 }
             )
-        return self.async_show_form(step_id="discovery_confirm")
+        return self.async_show_form(step_id=step_id)
+
+    async def async_step_discovery_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        return await self.async_step_confirm(step_id="discovery_confirm", user_input=user_input)
+
+
+    async def async_step_manual_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+
+        return await self.async_step_confirm(step_id="manual_confirm", user_input=user_input)

custom_components/powersensor/const.py

@@ -9,6 +9,7 @@
 CREATE_SENSOR_SIGNAL = f"{DOMAIN}_create_sensor"
 DATA_UPDATE_SIGNAL_FMT_MAC_EVENT = f"{DOMAIN}_data_update_%s_%s"
 HAVE_SOLAR_SENSOR_SIGNAL = f"{DOMAIN}_have_solar_sensor"
+HAVE_MAINS_SENSOR_SIGNAL = f"{DOMAIN}_have_mains_sensor"
 ROLE_UPDATE_SIGNAL = f"{DOMAIN}_update_role"
 PLUG_ADDED_TO_HA_SIGNAL = f"{DOMAIN}_plug_added_to_homeassistant"
 SENSOR_ADDED_TO_HA_SIGNAL = f"{DOMAIN}_sensor_added_to_homeassistant"

custom_components/powersensor/sensor.py

@@ -1,6 +1,7 @@
 """Sensor platform for the integration."""
 from __future__ import annotations
 
+import asyncio
 import copy
 import logging
 
@@ -11,18 +12,24 @@
 
 from . import PowersensorMessageDispatcher
 from .PlugMeasurements import PlugMeasurements
-from .PowersensorHouseholdEntity import HouseholdMeasurements, PowersensorHouseholdEntity, ConsumptionMeasurements, \
-    ProductionMeasurements
+from .PowersensorHouseholdEntity import (
+    HouseholdMeasurements,
+    PowersensorHouseholdEntity,
+    ConsumptionMeasurements,
+    ProductionMeasurements,
+)
 from .PowersensorPlugEntity import PowersensorPlugEntity
 from .PowersensorSensorEntity import PowersensorSensorEntity
 from .SensorMeasurements import SensorMeasurements
-from .const import (CREATE_PLUG_SIGNAL,
+from .const import (
+    CREATE_PLUG_SIGNAL,
     CREATE_SENSOR_SIGNAL,
     DATA_UPDATE_SIGNAL_FMT_MAC_EVENT,
     HAVE_SOLAR_SENSOR_SIGNAL,
     PLUG_ADDED_TO_HA_SIGNAL,
     ROLE_UPDATE_SIGNAL,
     SENSOR_ADDED_TO_HA_SIGNAL,
+    HAVE_MAINS_SENSOR_SIGNAL,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -37,6 +44,10 @@ async def async_setup_entry(
     vhh = entry.runtime_data["vhh"]
     dispatcher: PowersensorMessageDispatcher = entry.runtime_data['dispatcher']
 
+    entry.runtime_data['vhh_solar_create_lock'] = asyncio.Lock()
+    entry.runtime_data['vhh_solar_create_finished'] = False
+    entry.runtime_data['vhh_mains_create_lock'] = asyncio.Lock()
+    entry.runtime_data['vhh_mains_create_finished'] = False
 
     plug_role = "appliance"
 
@@ -77,9 +88,17 @@ async def handle_role_update(mac_address: str, new_role: str):
         if new_role == 'solar':
             new_data['with_solar'] = True  # Remember for next time we start
             persist_entry = True
-            async_dispatcher_send(hass, HAVE_SOLAR_SENSOR_SIGNAL)
+            if new_data.get('with_mains', False):
+                async_dispatcher_send(hass, HAVE_SOLAR_SENSOR_SIGNAL)
+
+        if new_role == 'house-net':
+            new_data['with_mains'] = True  # Remember for next time we start
+            persist_entry = True
+            async_dispatcher_send(hass, HAVE_MAINS_SENSOR_SIGNAL)
+            if new_data.get('with_solar', False):
+                async_dispatcher_send(hass, HAVE_SOLAR_SENSOR_SIGNAL)
 
-        # TODO: for house-net/solar <-> we'd need to change the entities too
+        # TODO: for house-net/solar/appliance <-> water we'd need to change the entities too
 
         if persist_entry:
             hass.config_entries.async_update_entry(entry, data=new_data)
@@ -114,10 +133,13 @@ async def handle_discovered_sensor(sensor_mac: str, sensor_role: str):
         ]
         async_add_entities(new_sensors, True)
         async_dispatcher_send(hass, SENSOR_ADDED_TO_HA_SIGNAL, sensor_mac, sensor_role)
-
-        if sensor_role == "solar":
+        mains_present = entry.data.get('with_mains', False)
+        if sensor_role == "solar" and mains_present:
             async_dispatcher_send(hass, HAVE_SOLAR_SENSOR_SIGNAL)
 
+        if sensor_role == "mains":
+            async_dispatcher_send(hass, HAVE_MAINS_SENSOR_SIGNAL)
+
     entry.async_on_unload(
         async_dispatcher_connect(
             hass, CREATE_SENSOR_SIGNAL, handle_discovered_sensor
@@ -131,21 +153,46 @@ async def handle_discovered_sensor(sensor_mac: str, sensor_role: str):
         await handle_discovered_sensor(mac, role)
 
     # Register the virtual household entities
-    household_entities = []
-    for measurement_type in ConsumptionMeasurements:
-        household_entities.append(PowersensorHouseholdEntity(vhh, measurement_type))
-    async_add_entities(household_entities)
+
+
+    async def add_mains_to_virtual_household():
+        async with entry.runtime_data['vhh_mains_create_lock']:
+            if entry.runtime_data['vhh_mains_create_finished']:
+                return
+            _LOGGER.debug("Enabling mains components in virtual household")
+            household_entities = []
+            for measurement_type in ConsumptionMeasurements:
+                household_entities.append(PowersensorHouseholdEntity(vhh, measurement_type))
+            async_add_entities(household_entities)
+            entry.runtime_data['vhh_mains_create_finished'] = True
+
+    with_mains = entry.data.get('with_mains', False)
+    if with_mains:
+        await add_mains_to_virtual_household()
+    else:
+        entry.async_on_unload(
+            async_dispatcher_connect(
+                hass, HAVE_MAINS_SENSOR_SIGNAL, add_mains_to_virtual_household
+            )
+        )
 
     async def add_solar_to_virtual_household():
-        _LOGGER.debug("Enabling solar components in virtual household")
-        solar_household_entities = []
-        for solar_measurement_type in ProductionMeasurements:
-            solar_household_entities.append(PowersensorHouseholdEntity(vhh, solar_measurement_type))
+        async with entry.runtime_data['vhh_solar_create_lock']:
+            if entry.runtime_data['vhh_solar_create_finished']:
+                return
+
+            _LOGGER.debug("Enabling solar components in virtual household")
+            solar_household_entities = []
+            for solar_measurement_type in ProductionMeasurements:
+                solar_household_entities.append(PowersensorHouseholdEntity(vhh, solar_measurement_type))
+
+            async_add_entities(solar_household_entities)
+            entry.runtime_data['vhh_solar_create_finished'] = True
 
-        async_add_entities(solar_household_entities)
 
     with_solar = entry.data.get('with_solar', False)
-    if with_solar:
+    with_mains = entry.data.get('with_mains', False)
+    if with_solar and with_mains:
         await add_solar_to_virtual_household()
     else:
         entry.async_on_unload(

custom_components/powersensor/translations/en.json

@@ -6,6 +6,10 @@
         "description": "Do you want to add Powersensor to Home Assistant?",
         "title": "Powersensor plugs discovered"
       },
+      "manual_confirm": {
+        "description": "No Powersensor plugs were discovered on your network. You can still add the integration and if plugs are later discovered they will be added to Home Assistant. Do you want to add Powersensor to Home Assistant?",
+        "title": "No Powersensor plugs discovered"
+      },
       "reconfigure" : {
         "title" : "Update sensor roles",
         "description": "Note: Roles provided by sensors will override user settings"