Sync with latest core PR

Author: markhannon

custom_components/zimi/__init__.py

@@ -7,15 +7,23 @@
 from zcc import ControlPoint, ControlPointError
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_HOST, CONF_PORT
+from homeassistant.const import CONF_HOST, CONF_PORT, Platform
 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 DOMAIN, PLATFORMS
+from .const import DOMAIN
 from .helpers import async_connect_to_controller
 
+PLATFORMS = [
+    Platform.COVER,
+    Platform.FAN,
+    Platform.LIGHT,
+    Platform.SENSOR,
+    Platform.SWITCH,
+]
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -24,7 +32,6 @@
 
 async def async_setup_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> bool:
     """Connect to Zimi Controller and register device."""
-    _LOGGER.debug("Zimi setup starting")
 
     try:
         api = await async_connect_to_controller(
@@ -35,9 +42,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> bool
     except ControlPointError as error:
         raise ConfigEntryNotReady(f"Zimi setup failed: {error}") from error
 
-    if not api:
-        raise ConfigEntryNotReady("Zimi setup failed: not ready")
-
     _LOGGER.debug("\n%s", api.describe())
 
     entry.runtime_data = api
@@ -47,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> bool
         config_entry_id=entry.entry_id,
         identifiers={(DOMAIN, api.mac)},
         manufacturer=api.brand,
-        name=f"Controller ({api.host}:{api.port})",
+        name=f"{api.network_name}",
         model="Zimi Cloud Connect",
         sw_version=api.firmware_version,
         connections={(CONNECTION_NETWORK_MAC, api.mac)},
@@ -64,7 +68,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> boo
     """Unload a config entry."""
 
     api = entry.runtime_data
-    if api:
-        api.disconnect()
+    api.disconnect()
 
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

custom_components/zimi/config_flow.py

@@ -2,18 +2,19 @@
 
 from __future__ import annotations
 
-import contextlib
 import logging
-import socket
 from typing import Any
 
-from enum import StrEnum
 import voluptuous as vol
 from zcc import (
     ControlPoint,
+    ControlPointCannotConnectError,
+    ControlPointConnectionRefusedError,
     ControlPointDescription,
     ControlPointDiscoveryService,
     ControlPointError,
+    ControlPointInvalidHostError,
+    ControlPointTimeoutError,
 )
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
@@ -26,46 +27,27 @@
     SelectSelectorMode,
 )
 
-from . import async_connect_to_controller
-from .const import DEFAULT_PORT, DOMAIN, TITLE
+from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
+DEFAULT_PORT = 5003
+STEP_MANUAL_DATA_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_HOST, default=""): str,
+        vol.Required(CONF_HOST): str,
         vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
     }
 )
 
 SELECTED_HOST_AND_PORT = "selected_host_and_port"
 
 
-class ZimiConfigErrors(StrEnum):
-    """ZimiConfig errors."""
-
-    ALREADY_CONFIGURED = "already_configured"
-    CANNOT_CONNECT = "cannot_connect"
-    CONNECTION_REFUSED = "connection_refused"
-    DISCOVERY_FAILURE = "discovery_failure"
-    INVALID_HOST = "invalid_host"
-    INVALID_PORT = "invalid_port"
-    TIMEOUT = "timeout"
-    UNKNOWN = "unknown"
-
-
 class ZimiConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for zcc."""
 
     api: ControlPoint = None
     api_descriptions: list[ControlPointDescription]
     data: dict[str, Any]
 
-    def __del__(self):
-        """Disconnect from ZCC."""
-        if self.api:
-            self.api.disconnect()
-
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -75,13 +57,14 @@ async def async_step_user(
 
         try:
             self.api_descriptions = await ControlPointDiscoveryService().discovers()
-        except ControlPointError as e:
-            _LOGGER.error(e)
+        except ControlPointError:
+            # ControlPointError is expected if no zcc are found on LAN
             return await self.async_step_manual()
 
         if len(self.api_descriptions) == 1:
             self.data[CONF_HOST] = self.api_descriptions[0].host
             self.data[CONF_PORT] = self.api_descriptions[0].port
+            await self.check_connection(self.data[CONF_HOST], self.data[CONF_PORT])
             return await self.create_entry()
 
         return await self.async_step_selection()
@@ -91,14 +74,16 @@ async def async_step_selection(
     ) -> ConfigFlowResult:
         """Handle selection of zcc to configure if multiple are discovered."""
 
-        errors: dict[str, str] = {}
+        errors: dict[str, str] | None = {}
 
         if user_input is not None:
-            self.data[CONF_HOST] = user_input[SELECTED_HOST_AND_PORT].split(":")[
-                0]
-            self.data[CONF_PORT] = int(
-                user_input[SELECTED_HOST_AND_PORT].split(":")[1])
-            return await self.create_entry()
+            self.data[CONF_HOST] = user_input[SELECTED_HOST_AND_PORT].split(":")[0]
+            self.data[CONF_PORT] = int(user_input[SELECTED_HOST_AND_PORT].split(":")[1])
+            errors = await self.check_connection(
+                self.data[CONF_HOST], self.data[CONF_PORT]
+            )
+            if not errors:
+                return await self.create_entry()
 
         available_options = [
             SelectOptionDict(
@@ -130,12 +115,12 @@ async def async_step_manual(
     ) -> ConfigFlowResult:
         """Handle manual configuration step if needed."""
 
-        errors: dict[str, str] = {}
+        errors: dict[str, str] | None = {}
 
         if user_input is not None:
             self.data = {**self.data, **user_input}
 
-            errors = await self.validate_connection(
+            errors = await self.check_connection(
                 self.data[CONF_HOST], self.data[CONF_PORT]
             )
 
@@ -145,73 +130,43 @@ async def async_step_manual(
         return self.async_show_form(
             step_id="manual",
             data_schema=self.add_suggested_values_to_schema(
-                STEP_USER_DATA_SCHEMA, self.data
+                STEP_MANUAL_DATA_SCHEMA, self.data
             ),
             errors=errors,
         )
 
-    async def create_entry(self) -> ConfigFlowResult:
-        """Create entry for zcc."""
+    async def check_connection(self, host: str, port: int) -> dict[str, str] | None:
+        """Check connection to zcc.
 
-        if not self.api:
-            with contextlib.suppress(ControlPointError):
-                self.api = await async_connect_to_controller(
-                    self.data[CONF_HOST], self.data[CONF_PORT], fast=False
-                )
+        Stores mac and returns None if successful, otherwise returns error message.
+        """
 
-        if self.api and self.api.ready:
-            self.data[CONF_MAC] = format_mac(self.api.mac)
-            self.api.disconnect()
-            await self.async_set_unique_id(self.data[CONF_MAC])
-            self._abort_if_unique_id_configured()
-            return self.async_create_entry(
-                title=f"{TITLE} ({self.data[CONF_HOST]}:{self.data[CONF_PORT]})",
-                data=self.data,
+        try:
+            result = await ControlPointDiscoveryService().validate_connection(
+                self.data[CONF_HOST], self.data[CONF_PORT]
             )
+        except ControlPointInvalidHostError:
+            return {"base": "invalid_host"}
+        except ControlPointConnectionRefusedError:
+            return {"base": "connection_refused"}
+        except ControlPointCannotConnectError:
+            return {"base": "cannot_connect"}
+        except ControlPointTimeoutError:
+            return {"base": "timeout"}
+        except Exception:
+            _LOGGER.exception("Unexpected error")
+            return {"base": "unknown"}
+
+        self.data[CONF_MAC] = format_mac(result.mac)
+
+        return None
 
-        return self.async_abort(reason="cannot_connect")
-
-    async def validate_connection(self, host: str, port: int) -> dict[str, str]:
-        """Check for errors with configuration.
-
-        1. Check connectivity to configured host and port; and
-        2. Connect to ZCC to get mac address and store in self.data
-
-        Return error dictionary upon failure.
-        """
+    async def create_entry(self) -> ConfigFlowResult:
+        """Create entry for zcc."""
 
-        try:
-            hostbyname = socket.gethostbyname(host)
-        except socket.gaierror as e:
-            _LOGGER.error(e)
-            return {"base": ZimiConfigErrors.INVALID_HOST}
-        if hostbyname:
-            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            s.settimeout(10)
-            try:
-                s.connect((host, port))
-                s.close()
-            except ConnectionRefusedError as e:
-                _LOGGER.error(e)
-                return {"base": ZimiConfigErrors.CONNECTION_REFUSED}
-            except TimeoutError as e:
-                _LOGGER.error(e)
-                return {"base": ZimiConfigErrors.TIMEOUT}
-            except socket.gaierror as e:
-                _LOGGER.error(e)
-                return {"base": ZimiConfigErrors.CANNOT_CONNECT}
-        else:
-            return {"base": ZimiConfigErrors.INVALID_HOST}
-
-        if not self.api or not self.api.ready:
-            try:
-                self.api = await async_connect_to_controller(host, port, fast=True)
-            except ControlPointError as e:
-                _LOGGER.error(e)
-                return {"base": ZimiConfigErrors.CANNOT_CONNECT}
-
-        self.data[CONF_MAC] = format_mac(self.api.mac)
-        self.api.disconnect()
-        self.api = None
-
-        return {}
+        await self.async_set_unique_id(self.data[CONF_MAC])
+        self._abort_if_unique_id_configured()
+        return self.async_create_entry(
+            title=f"ZIMI Controller ({self.data[CONF_HOST]}:{self.data[CONF_PORT]})",
+            data=self.data,
+        )

custom_components/zimi/const.py

@@ -1,15 +1,3 @@
 """Constants for the zcc integration."""
 
-from homeassistant.const import Platform
-
-CONTROLLER = "zimi_controller"
-DEFAULT_PORT = 5003
 DOMAIN = "zimi"
-PLATFORMS = [
-    Platform.COVER,
-    Platform.FAN,
-    Platform.LIGHT,
-    Platform.SENSOR,
-    Platform.SWITCH,
-]
-TITLE = "ZIMI Controller"