Remove sunweg integration (#124230)

* chore(sunweg): remove sunweg integration

* Update homeassistant/components/sunweg/strings.json

Co-authored-by: Abílio Costa <abmantis@users.noreply.github.com>

* Update homeassistant/components/sunweg/manifest.json

Co-authored-by: Abílio Costa <abmantis@users.noreply.github.com>

* feat: added async remove entry

* Clean setup_entry; add tests

---------

Co-authored-by: Abílio Costa <abmantis@users.noreply.github.com>
Co-authored-by: abmantis <amfcalt@gmail.com>

Author: rokam

CODEOWNERS

@@ -1,197 +1,39 @@
 """The Sun WEG inverter sensor integration."""
 
-import datetime
-import json
-import logging
-
-from sunweg.api import APIHelper
-from sunweg.plant import Plant
-
-from homeassistant import config_entries
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.typing import StateType, UndefinedType
-from homeassistant.util import Throttle
-
-from .const import CONF_PLANT_ID, DOMAIN, PLATFORMS, DeviceType
+from homeassistant.helpers import issue_registry as ir
 
-SCAN_INTERVAL = datetime.timedelta(minutes=5)
+DOMAIN = "sunweg"
 
-_LOGGER = logging.getLogger(__name__)
 
-
-async def async_setup_entry(
-    hass: HomeAssistant, entry: config_entries.ConfigEntry
-) -> bool:
+async def async_setup_entry(hass: HomeAssistant, _: ConfigEntry) -> bool:
     """Load the saved entities."""
-    api = APIHelper(entry.data[CONF_USERNAME], entry.data[CONF_PASSWORD])
-    if not await hass.async_add_executor_job(api.authenticate):
-        raise ConfigEntryAuthFailed("Username or Password may be incorrect!")
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = SunWEGData(
-        api, entry.data[CONF_PLANT_ID]
+    ir.async_create_issue(
+        hass,
+        DOMAIN,
+        DOMAIN,
+        is_fixable=False,
+        severity=ir.IssueSeverity.ERROR,
+        translation_key="integration_removed",
+        translation_placeholders={
+            "issue": "https://github.com/rokam/sunweg/issues/13",
+            "entries": "/config/integrations/integration/sunweg",
+        },
     )
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
     return True
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    hass.data[DOMAIN].pop(entry.entry_id)
-    if len(hass.data[DOMAIN]) == 0:
-        hass.data.pop(DOMAIN)
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-
-
-class SunWEGData:
-    """The class for handling data retrieval."""
-
-    def __init__(
-        self,
-        api: APIHelper,
-        plant_id: int,
-    ) -> None:
-        """Initialize the probe."""
-
-        self.api = api
-        self.plant_id = plant_id
-        self.data: Plant = None
-        self.previous_values: dict = {}
-
-    @Throttle(SCAN_INTERVAL)
-    def update(self) -> None:
-        """Update probe data."""
-        _LOGGER.debug("Updating data for plant %s", self.plant_id)
-        try:
-            self.data = self.api.plant(self.plant_id)
-            for inverter in self.data.inverters:
-                self.api.complete_inverter(inverter)
-        except json.decoder.JSONDecodeError:
-            _LOGGER.error("Unable to fetch data from SunWEG server")
-        _LOGGER.debug("Finished updating data for plant %s", self.plant_id)
-
-    def get_api_value(
-        self,
-        variable: str,
-        device_type: DeviceType,
-        inverter_id: int = 0,
-        deep_name: str | None = None,
-    ):
-        """Retrieve from a Plant the desired variable value."""
-        if device_type == DeviceType.TOTAL:
-            return self.data.__dict__.get(variable)
-
-        inverter_list = [i for i in self.data.inverters if i.id == inverter_id]
-        if len(inverter_list) == 0:
-            return None
-        inverter = inverter_list[0]
-
-        if device_type == DeviceType.INVERTER:
-            return inverter.__dict__.get(variable)
-        if device_type == DeviceType.PHASE:
-            for phase in inverter.phases:
-                if phase.name == deep_name:
-                    return phase.__dict__.get(variable)
-        elif device_type == DeviceType.STRING:
-            for mppt in inverter.mppts:
-                for string in mppt.strings:
-                    if string.name == deep_name:
-                        return string.__dict__.get(variable)
-        return None
-
-    def get_data(
-        self,
-        *,
-        api_variable_key: str,
-        api_variable_unit: str | None,
-        deep_name: str | None,
-        device_type: DeviceType,
-        inverter_id: int,
-        name: str | UndefinedType | None,
-        native_unit_of_measurement: str | None,
-        never_resets: bool,
-        previous_value_drop_threshold: float | None,
-    ) -> tuple[StateType | datetime.datetime, str | None]:
-        """Get the data."""
-        _LOGGER.debug(
-            "Data request for: %s",
-            name,
-        )
-        variable = api_variable_key
-        previous_unit = native_unit_of_measurement
-        api_value = self.get_api_value(variable, device_type, inverter_id, deep_name)
-        previous_value = self.previous_values.get(variable)
-        return_value = api_value
-        if api_variable_unit is not None:
-            native_unit_of_measurement = self.get_api_value(
-                api_variable_unit,
-                device_type,
-                inverter_id,
-                deep_name,
-            )
-
-        # If we have a 'drop threshold' specified, then check it and correct if needed
-        if (
-            previous_value_drop_threshold is not None
-            and previous_value is not None
-            and api_value is not None
-            and previous_unit == native_unit_of_measurement
-        ):
-            _LOGGER.debug(
-                (
-                    "%s - Drop threshold specified (%s), checking for drop... API"
-                    " Value: %s, Previous Value: %s"
-                ),
-                name,
-                previous_value_drop_threshold,
-                api_value,
-                previous_value,
-            )
-            diff = float(api_value) - float(previous_value)
-
-            # Check if the value has dropped (negative value i.e. < 0) and it has only
-            # dropped by a small amount, if so, use the previous value.
-            # Note - The energy dashboard takes care of drops within 10%
-            # of the current value, however if the value is low e.g. 0.2
-            # and drops by 0.1 it classes as a reset.
-            if -(previous_value_drop_threshold) <= diff < 0:
-                _LOGGER.debug(
-                    (
-                        "Diff is negative, but only by a small amount therefore not a"
-                        " nightly reset, using previous value (%s) instead of api value"
-                        " (%s)"
-                    ),
-                    previous_value,
-                    api_value,
-                )
-                return_value = previous_value
-            else:
-                _LOGGER.debug("%s - No drop detected, using API value", name)
-
-        # Lifetime total values should always be increasing, they will never reset,
-        # however the API sometimes returns 0 values when the clock turns to 00:00
-        # local time in that scenario we should just return the previous value
-        # Scenarios:
-        # 1 - System has a genuine 0 value when it it first commissioned:
-        #        - will return 0 until a non-zero value is registered
-        # 2 - System has been running fine but temporarily resets to 0 briefly
-        #     at midnight:
-        #        - will return the previous value
-        # 3 - HA is restarted during the midnight 'outage' - Not handled:
-        #        - Previous value will not exist meaning 0 will be returned
-        #        - This is an edge case that would be better handled by looking
-        #          up the previous value of the entity from the recorder
-        if never_resets and api_value == 0 and previous_value:
-            _LOGGER.debug(
-                (
-                    "API value is 0, but this value should never reset, returning"
-                    " previous value (%s) instead"
-                ),
-                previous_value,
-            )
-            return_value = previous_value
+    return True
 
-        self.previous_values[variable] = return_value
 
-        return (return_value, native_unit_of_measurement)
+async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Remove a config entry."""
+    if not hass.config_entries.async_loaded_entries(DOMAIN):
+        ir.async_delete_issue(hass, DOMAIN, DOMAIN)
+        # Remove any remaining disabled or ignored entries
+        for _entry in hass.config_entries.async_entries(DOMAIN):
+            hass.async_create_task(hass.config_entries.async_remove(_entry.entry_id))

homeassistant/components/sunweg/__init__.py

@@ -1,129 +1,11 @@
 """Config flow for Sun WEG integration."""
 
-from collections.abc import Mapping
-from typing import Any
+from homeassistant.config_entries import ConfigFlow
 
-from sunweg.api import APIHelper, SunWegApiError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_NAME, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import callback
-
-from .const import CONF_PLANT_ID, DOMAIN
+from . import DOMAIN
 
 
 class SunWEGConfigFlow(ConfigFlow, domain=DOMAIN):
     """Config flow class."""
 
     VERSION = 1
-
-    def __init__(self) -> None:
-        """Initialise sun weg server flow."""
-        self.api: APIHelper = None
-        self.data: dict[str, Any] = {}
-
-    @callback
-    def _async_show_user_form(self, step_id: str, errors=None) -> ConfigFlowResult:
-        """Show the form to the user."""
-        default_username = ""
-        if CONF_USERNAME in self.data:
-            default_username = self.data[CONF_USERNAME]
-        data_schema = vol.Schema(
-            {
-                vol.Required(CONF_USERNAME, default=default_username): str,
-                vol.Required(CONF_PASSWORD): str,
-            }
-        )
-
-        return self.async_show_form(
-            step_id=step_id, data_schema=data_schema, errors=errors
-        )
-
-    def _set_auth_data(
-        self, step: str, username: str, password: str
-    ) -> ConfigFlowResult | None:
-        """Set username and password."""
-        if self.api:
-            # Set username and password
-            self.api.username = username
-            self.api.password = password
-        else:
-            # Initialise the library with the username & password
-            self.api = APIHelper(username, password)
-
-        try:
-            if not self.api.authenticate():
-                return self._async_show_user_form(step, {"base": "invalid_auth"})
-        except SunWegApiError:
-            return self._async_show_user_form(step, {"base": "timeout_connect"})
-
-        return None
-
-    async def async_step_user(self, user_input=None) -> ConfigFlowResult:
-        """Handle the start of the config flow."""
-        if not user_input:
-            return self._async_show_user_form("user")
-
-        # Store authentication info
-        self.data = user_input
-
-        conf_result = await self.hass.async_add_executor_job(
-            self._set_auth_data,
-            "user",
-            user_input[CONF_USERNAME],
-            user_input[CONF_PASSWORD],
-        )
-
-        return await self.async_step_plant() if conf_result is None else conf_result
-
-    async def async_step_plant(self, user_input=None) -> ConfigFlowResult:
-        """Handle adding a "plant" to Home Assistant."""
-        plant_list = await self.hass.async_add_executor_job(self.api.listPlants)
-
-        if len(plant_list) == 0:
-            return self.async_abort(reason="no_plants")
-
-        plants = {plant.id: plant.name for plant in plant_list}
-
-        if user_input is None and len(plant_list) > 1:
-            data_schema = vol.Schema({vol.Required(CONF_PLANT_ID): vol.In(plants)})
-
-            return self.async_show_form(step_id="plant", data_schema=data_schema)
-
-        if user_input is None and len(plant_list) == 1:
-            user_input = {CONF_PLANT_ID: plant_list[0].id}
-
-        user_input[CONF_NAME] = plants[user_input[CONF_PLANT_ID]]
-        await self.async_set_unique_id(user_input[CONF_PLANT_ID])
-        self._abort_if_unique_id_configured()
-        self.data.update(user_input)
-        return self.async_create_entry(title=self.data[CONF_NAME], data=self.data)
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reauthorization request from SunWEG."""
-        self.data.update(entry_data)
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reauthorization flow."""
-        if user_input is None:
-            return self._async_show_user_form("reauth_confirm")
-
-        self.data.update(user_input)
-        conf_result = await self.hass.async_add_executor_job(
-            self._set_auth_data,
-            "reauth_confirm",
-            user_input[CONF_USERNAME],
-            user_input[CONF_PASSWORD],
-        )
-        if conf_result is not None:
-            return conf_result
-
-        return self.async_update_reload_and_abort(
-            self._get_reauth_entry(), data=self.data
-        )