Merge of latest core integration PR

Author: markhannon

custom_components/zimi/__init__.py

@@ -1,43 +1,75 @@
 """The zcc integration."""
+
 from __future__ import annotations
 
 import logging
 
+from zcc import ControlPoint, ControlPointError
+
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, CONF_PORT
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
 
-from .const import CONTROLLER, DOMAIN, VERBOSITY
-from .controller import ZimiController
+from .const import DOMAIN, PLATFORMS
+from .helpers import async_connect_to_controller
 
 _LOGGER = logging.getLogger(__name__)
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Connect to Zimi Controller and register device."""
+type ZimiConfigEntry = ConfigEntry[ControlPoint]
 
-    if entry.data.get(VERBOSITY, 0) > 1:
-        _LOGGER.setLevel(logging.DEBUG)
 
+async def async_setup_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> bool:
+    """Connect to Zimi Controller and register device."""
     _LOGGER.debug("Zimi setup starting")
 
-    controller = ZimiController(hass, entry)
-    connected = await controller.connect()
-    if not connected:
-        return False
+    try:
+        api = await async_connect_to_controller(
+            host=entry.data[CONF_HOST],
+            port=entry.data[CONF_PORT],
+        )
+
+    except ControlPointError as error:
+        _LOGGER.error("Initiation failed: %s", error)
+        raise ConfigEntryNotReady(error) from error
+
+    if not api:
+        msg = "Zimi setup failed: not ready"
+        _LOGGER.error(msg=msg)
+        raise ConfigEntryNotReady(msg)
 
-    hass.data[CONTROLLER] = controller
+    _LOGGER.debug("\n%s", api.describe())
+
+    entry.runtime_data = api
 
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
-        identifiers={(DOMAIN, controller.controller.mac)},
-        manufacturer=controller.controller.brand,
-        name=f"Zimi({controller.controller.host}:{controller.controller.port})",
-        model=controller.controller.product,
-        sw_version="unknown",
+        identifiers={(DOMAIN, api.mac)},
+        manufacturer=api.brand,
+        name=f"ZCC ({api.host}:{api.port})",
+        model=api.product,
+        model_id="Zimi Cloud Connect",
+        hw_version=api.firmware_version,
+        sw_version=api.api_version,
+        connections={(CONNECTION_NETWORK_MAC, api.mac)},
     )
 
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
     _LOGGER.debug("Zimi setup complete")
 
     return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> bool:
+    """Unload a config entry."""
+
+    api = entry.runtime_data
+    if api:
+        api.disconnect()
+
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

custom_components/zimi/config_flow.py

@@ -1,139 +1,130 @@
 """Config flow for zcc integration."""
+
 from __future__ import annotations
 
 import logging
 import socket
 from typing import Any
 
-import voluptuous as vol  # type: ignore[import]
-from zcc import ControlPointDiscoveryService, ControlPointError  # type: ignore[import]
+import voluptuous as vol
+from zcc import ControlPointDiscoveryService, ControlPointError
 
 from homeassistant import config_entries
-from homeassistant.const import CONF_HOST, CONF_PORT
-from homeassistant.data_entry_flow import FlowResult
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PORT
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.device_registry import format_mac
 
-from .const import DOMAIN, TIMEOUT, VERBOSITY, WATCHDOG
+from . import async_connect_to_controller
+from .const import DOMAIN, TITLE
 
 _LOGGER = logging.getLogger(__name__)
 
 STEP_USER_DATA_SCHEMA = vol.Schema(
     {
-        vol.Optional(CONF_HOST, default=""): str,
+        vol.Optional(CONF_HOST): str,
         vol.Optional(CONF_PORT, default=5003): int,
-        vol.Optional(TIMEOUT, default=3): int,
-        vol.Optional(WATCHDOG, default=1800): int,
-        vol.Optional(VERBOSITY, default=1): int,
+        vol.Required(CONF_MAC): str,
     }
 )
 
 
-class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for zcc."""
+class ZimiConfigException(Exception):
+    """Base class for config exceptions."""
 
-    VERSION = 1
+
+class ZimiConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for zcc."""
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
-    ) -> FlowResult:
+    ) -> config_entries.ConfigFlowResult:
         """Handle the initial step."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="user", data_schema=STEP_USER_DATA_SCHEMA
-            )
-
-        data = {}
-        errors = {}
-
-        try:
-            data = await self.validate_input(user_input)
-        except CannotConnect:
-            errors["base"] = "cannot_connect"
-        except ConnectionRefused:
-            errors["base"] = "connection_refused"
-        except DiscoveryFailure:
-            errors["base"] = "discovery_failure"
-        except InvalidAuth:
-            errors["base"] = "invalid_auth"
-        except InvalidHost:
-            errors["base"] = "invalid_host"
-        except TimeOut:
-            errors["base"] = "timeout"
-        except Exception:  # pylint: disable=broad-except
-            _LOGGER.exception("Unexpected exception during configuration steps")
-            errors["base"] = "unknown"
-        else:
-            return self.async_create_entry(title=data["title"], data=data)
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
 
-    async def validate_input(self, data: dict[str, Any]) -> dict[str, Any]:
-        """Validate the user input."""
+        api = None
+        errors: dict[str, str] = {}
+        description_placeholders: dict[str, str] = {}
 
-        if data[TIMEOUT] is None:
-            data[TIMEOUT] = 3
+        if user_input is not None:
+            data: dict[str, Any] = {}
 
-        if data[VERBOSITY] is None:
-            data[VERBOSITY] = 1
-
-        if data[WATCHDOG] is None:
-            data[WATCHDOG] = 1800
-
-        if data[CONF_HOST] == "":
-            try:
-                description = await ControlPointDiscoveryService().discover()
-                data[CONF_HOST] = description.host
-                data[CONF_PORT] = description.port
-            except ControlPointError as e:
-                raise DiscoveryFailure(e) from e
-        else:
             try:
-                socket.gethostbyname(data[CONF_HOST])
-            except socket.herror as e:
-                raise InvalidHost("%s is not a valid host" % data[CONF_HOST]) from e
-            try:
-                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                s.settimeout(10)
-                s.connect((data[CONF_HOST], int(data[CONF_PORT])))
-            except ConnectionRefusedError as e:
-                raise ConnectionRefused() from e
-            except TimeoutError as e:
-                raise TimeOut() from e
-            except Exception as e:
-                raise CannotConnect() from e
-
-        # Return info that you want to store in the config entry.
-        return {
-            "title": "ZIMI Controller",
-            "host": data[CONF_HOST],
-            "port": data[CONF_PORT],
-            "timeout": data[TIMEOUT],
-            "verbosity": data[VERBOSITY],
-            "watchdog": data[WATCHDOG],
-        }
-
+                if not user_input[CONF_HOST]:
+                    try:
+                        description = await ControlPointDiscoveryService().discover()
+                    except ControlPointError as e:
+                        errors["base"] = "discovery_failure"
+                        raise ZimiConfigException(errors["base"]) from e
+                    data[CONF_HOST] = description.host
+                    data[CONF_PORT] = description.port
+                else:
+                    hostbyname = None
+                    data[CONF_HOST] = user_input[CONF_HOST]
+                    data[CONF_PORT] = user_input[CONF_PORT]
+                    try:
+                        hostbyname = socket.gethostbyname(data[CONF_HOST])
+                    except socket.gaierror as e:
+                        errors["base"] = "invalid_host"
+                        raise ZimiConfigException(errors["base"]) from e
+                    if hostbyname:
+                        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                        s.settimeout(10)
+                        try:
+                            s.connect((data[CONF_HOST], data[CONF_PORT]))
+                            s.close()
+                        except ConnectionRefusedError as e:
+                            errors["base"] = "connection_refused"
+                            raise ZimiConfigException(errors["base"]) from e
+                        except TimeoutError as e:
+                            errors["base"] = "timeout"
+                            raise ZimiConfigException(errors["base"]) from e
+                        except socket.gaierror as e:
+                            errors["base"] = "cannot_connect"
+                            raise ZimiConfigException(errors["base"]) from e
+                    else:
+                        errors["base"] = "invalid_host"
+                        raise ZimiConfigException(errors["base"])  # noqa: TRY301
+
+                data[CONF_MAC] = format_mac(user_input[CONF_MAC])
+                if data[CONF_MAC] is user_input[CONF_MAC]:
+                    errors["base"] = "invalid_mac"
+                    raise ZimiConfigException(errors["base"])  # noqa: TRY301
+
+                try:
+                    api = await async_connect_to_controller(
+                        data[CONF_HOST], data[CONF_PORT], fast=True
+                    )
+                except ConfigEntryNotReady as e:
+                    errors["base"] = "cannot_connect"
+                    raise ZimiConfigException(errors["base"]) from e
+
+                if api:
+                    if data[CONF_MAC] != format_mac(api.mac):
+                        msg = f"{data[CONF_MAC]} != {format_mac(api.mac)}"
+                        _LOGGER.error("Configured mac mismatch: %s", msg)
+                        errors["base"] = "mismatched_mac"
+                        description_placeholders["error_detail"] = msg
+                        raise ZimiConfigException(errors["base"])  # noqa: TRY301
+                else:
+                    errors["base"] = "cannot_connect"
+                    raise ZimiConfigException(errors["base"])  # noqa: TRY301
+
+            except ZimiConfigException:
+                _LOGGER.exception("Exception during configuration steps")
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception during configuration steps")
+                errors["base"] = "unknown"
+
+            if api:
+                api.disconnect()
+
+            if not errors:
+                await self.async_set_unique_id(data[CONF_MAC])
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title=TITLE, data=data)
 
-class CannotConnect(HomeAssistantError):
-    """Error to indicate we cannot connect."""
-
-
-class ConnectionRefused(HomeAssistantError):
-    """Error to indicate connection was refused."""
-
-
-class DiscoveryFailure(HomeAssistantError):
-    """Error to indicate that Zimi UDP discovery failed."""
-
-
-class InvalidAuth(HomeAssistantError):
-    """Error to indicate there is invalid auth."""
-
-
-class InvalidHost(HomeAssistantError):
-    """Error to indicate that host IP address is invalid."""
-
-
-class TimeOut(HomeAssistantError):
-    """Error to indicate timeout when attempting to connect."""
+        return self.async_show_form(
+            step_id="user",
+            data_schema=STEP_USER_DATA_SCHEMA,
+            errors=errors,
+            description_placeholders=description_placeholders,
+        )

custom_components/zimi/const.py

@@ -1,9 +1,14 @@
 """Constants for the zcc integration."""
 
+from homeassistant.const import Platform
+
 CONTROLLER = "zimi_controller"
 DOMAIN = "zimi"
-PLATFORMS = ["light", "sensor", "switch", "cover", "fan"]
-
-TIMEOUT = "timeout"
-VERBOSITY = "verbosity"
-WATCHDOG = "watchdog"
+PLATFORMS = [
+    Platform.COVER,
+    Platform.FAN,
+    Platform.LIGHT,
+    Platform.SENSOR,
+    Platform.SWITCH,
+]
+TITLE = "ZIMI Controller"