Address review comments

CODEOWNERS

@@ -945,8 +945,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/knx/ @Julius2342 @farmio @marvin-w
 /homeassistant/components/kodi/ @OnFreund
 /tests/components/kodi/ @OnFreund
-/homeassistant/components/konnected/ @heythisisnate
-/tests/components/konnected/ @heythisisnate
 /homeassistant/components/kostal_plenticore/ @stegm
 /tests/components/kostal_plenticore/ @stegm
 /homeassistant/components/kraken/ @eifinger

homeassistant/components/konnected/__init__.py

@@ -1,450 +1,53 @@
-"""Support for Konnected devices."""
-# pylint: disable=home-assistant-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern
+"""The Konnected.io integration."""
 
-import copy
-import hmac
-from http import HTTPStatus
-import json
-import logging
-
-from aiohttp.hdrs import AUTHORIZATION
-from aiohttp.web import Request, Response
 import voluptuous as vol
 
-from homeassistant import config_entries
-from homeassistant.components.binary_sensor import DEVICE_CLASSES_SCHEMA
-from homeassistant.components.http import KEY_HASS, HomeAssistantView
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    CONF_ACCESS_TOKEN,
-    CONF_BINARY_SENSORS,
-    CONF_DEVICES,
-    CONF_DISCOVERY,
-    CONF_HOST,
-    CONF_ID,
-    CONF_NAME,
-    CONF_PIN,
-    CONF_PORT,
-    CONF_REPEAT,
-    CONF_SENSORS,
-    CONF_SWITCHES,
-    CONF_TYPE,
-    CONF_ZONE,
-    STATE_OFF,
-    STATE_ON,
-    Platform,
-)
+from homeassistant.config_entries import ConfigEntry, ConfigEntryState
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, issue_registry as ir
 from homeassistant.helpers.typing import ConfigType
 
-from .config_flow import (  # Loading the config flow file will register the flow
-    CONF_DEFAULT_OPTIONS,
-    CONF_IO,
-    CONF_IO_BIN,
-    CONF_IO_DIG,
-    CONF_IO_SWI,
-    OPTIONS_SCHEMA,
-)
-from .const import (
-    CONF_ACTIVATION,
-    CONF_API_HOST,
-    CONF_BLINK,
-    CONF_INVERSE,
-    CONF_MOMENTARY,
-    CONF_PAUSE,
-    CONF_POLL_INTERVAL,
-    DOMAIN,
-    PIN_TO_ZONE,
-    STATE_HIGH,
-    STATE_LOW,
-    UPDATE_ENDPOINT,
-    ZONE_TO_PIN,
-    ZONES,
-)
-from .handlers import HANDLERS
-from .panel import AlarmPanel
+from .const import DOMAIN
 
-_LOGGER = logging.getLogger(__name__)
-
-
-def ensure_pin(value):
-    """Check if valid pin and coerce to string."""
-    if value is None:
-        raise vol.Invalid("pin value is None")
-
-    if PIN_TO_ZONE.get(str(value)) is None:
-        raise vol.Invalid("pin not valid")
-
-    return str(value)
-
-
-def ensure_zone(value):
-    """Check if valid zone and coerce to string."""
-    if value is None:
-        raise vol.Invalid("zone value is None")
-
-    if str(value) not in ZONES:
-        raise vol.Invalid("zone not valid")
-
-    return str(value)
-
-
-def import_device_validator(config):
-    """Validate zones and reformat for import."""
-    config = copy.deepcopy(config)
-    io_cfgs = {}
-    # Replace pins with zones
-    for conf_platform, conf_io in (
-        (CONF_BINARY_SENSORS, CONF_IO_BIN),
-        (CONF_SENSORS, CONF_IO_DIG),
-        (CONF_SWITCHES, CONF_IO_SWI),
-    ):
-        for zone in config.get(conf_platform, []):
-            if zone.get(CONF_PIN):
-                zone[CONF_ZONE] = PIN_TO_ZONE[zone[CONF_PIN]]
-                del zone[CONF_PIN]
-            io_cfgs[zone[CONF_ZONE]] = conf_io
-
-    # Migrate config_entry data into default_options structure
-    config[CONF_IO] = io_cfgs
-    config[CONF_DEFAULT_OPTIONS] = OPTIONS_SCHEMA(config)
-
-    # clean up fields migrated to options
-    config.pop(CONF_BINARY_SENSORS, None)
-    config.pop(CONF_SENSORS, None)
-    config.pop(CONF_SWITCHES, None)
-    config.pop(CONF_BLINK, None)
-    config.pop(CONF_DISCOVERY, None)
-    config.pop(CONF_API_HOST, None)
-    config.pop(CONF_IO, None)
-    return config
-
-
-def import_validator(config):
-    """Reformat for import."""
-    config = copy.deepcopy(config)
-
-    # push api_host into device configs
-    for device in config.get(CONF_DEVICES, []):
-        device[CONF_API_HOST] = config.get(CONF_API_HOST, "")
-
-    return config
-
-
-# configuration.yaml schemas (legacy)
-BINARY_SENSOR_SCHEMA_YAML = vol.All(
-    vol.Schema(
-        {
-            vol.Exclusive(CONF_ZONE, "s_io"): ensure_zone,
-            vol.Exclusive(CONF_PIN, "s_io"): ensure_pin,
-            vol.Required(CONF_TYPE): DEVICE_CLASSES_SCHEMA,
-            vol.Optional(CONF_NAME): cv.string,
-            vol.Optional(CONF_INVERSE, default=False): cv.boolean,
-        }
-    ),
-    cv.has_at_least_one_key(CONF_PIN, CONF_ZONE),
-)
-
-SENSOR_SCHEMA_YAML = vol.All(
-    vol.Schema(
-        {
-            vol.Exclusive(CONF_ZONE, "s_io"): ensure_zone,
-            vol.Exclusive(CONF_PIN, "s_io"): ensure_pin,
-            vol.Required(CONF_TYPE): vol.All(vol.Lower, vol.In(["dht", "ds18b20"])),
-            vol.Optional(CONF_NAME): cv.string,
-            vol.Optional(CONF_POLL_INTERVAL, default=3): vol.All(
-                vol.Coerce(int), vol.Range(min=1)
-            ),
-        }
-    ),
-    cv.has_at_least_one_key(CONF_PIN, CONF_ZONE),
-)
-
-SWITCH_SCHEMA_YAML = vol.All(
-    vol.Schema(
-        {
-            vol.Exclusive(CONF_ZONE, "s_io"): ensure_zone,
-            vol.Exclusive(CONF_PIN, "s_io"): ensure_pin,
-            vol.Optional(CONF_NAME): cv.string,
-            vol.Optional(CONF_ACTIVATION, default=STATE_HIGH): vol.All(
-                vol.Lower, vol.Any(STATE_HIGH, STATE_LOW)
-            ),
-            vol.Optional(CONF_MOMENTARY): vol.All(vol.Coerce(int), vol.Range(min=10)),
-            vol.Optional(CONF_PAUSE): vol.All(vol.Coerce(int), vol.Range(min=10)),
-            vol.Optional(CONF_REPEAT): vol.All(vol.Coerce(int), vol.Range(min=-1)),
-        }
-    ),
-    cv.has_at_least_one_key(CONF_PIN, CONF_ZONE),
-)
-
-DEVICE_SCHEMA_YAML = vol.All(
-    vol.Schema(
-        {
-            vol.Required(CONF_ID): cv.matches_regex("[0-9a-f]{12}"),
-            vol.Optional(CONF_BINARY_SENSORS): vol.All(
-                cv.ensure_list, [BINARY_SENSOR_SCHEMA_YAML]
-            ),
-            vol.Optional(CONF_SENSORS): vol.All(cv.ensure_list, [SENSOR_SCHEMA_YAML]),
-            vol.Optional(CONF_SWITCHES): vol.All(cv.ensure_list, [SWITCH_SCHEMA_YAML]),
-            vol.Inclusive(CONF_HOST, "host_info"): cv.string,
-            vol.Inclusive(CONF_PORT, "host_info"): cv.port,
-            vol.Optional(CONF_BLINK, default=True): cv.boolean,
-            vol.Optional(CONF_API_HOST, default=""): vol.Any("", cv.url),
-            vol.Optional(CONF_DISCOVERY, default=True): cv.boolean,
-        }
-    ),
-    import_device_validator,
-)
-
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.All(
-            import_validator,
-            vol.Schema(
-                {
-                    vol.Required(CONF_ACCESS_TOKEN): cv.string,
-                    vol.Optional(CONF_API_HOST): vol.Url(),
-                    vol.Optional(CONF_DEVICES): vol.All(
-                        cv.ensure_list, [DEVICE_SCHEMA_YAML]
-                    ),
-                }
-            ),
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
-
-YAML_CONFIGS = "yaml_configs"
-PLATFORMS = [Platform.BINARY_SENSOR, Platform.SENSOR, Platform.SWITCH]
+CONFIG_SCHEMA = vol.Schema({DOMAIN: cv.match_all}, extra=vol.ALLOW_EXTRA)
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Konnected platform."""
-    ir.async_create_issue(
-        hass,
-        DOMAIN,
-        "deprecated_firmware",
-        breaks_in_ha_version="2026.4.0",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        severity=ir.IssueSeverity.WARNING,
-        translation_key="deprecated_firmware",
-        translation_placeholders={
-            "kb_page_url": "https://support.konnected.io/migrating-from-konnected-legacy-home-assistant-integration-to-esphome",
-        },
-    )
-    if (cfg := config.get(DOMAIN)) is None:
-        cfg = {}
-
-    if DOMAIN not in hass.data:
-        hass.data[DOMAIN] = {
-            CONF_ACCESS_TOKEN: cfg.get(CONF_ACCESS_TOKEN),
-            CONF_API_HOST: cfg.get(CONF_API_HOST),
-            CONF_DEVICES: {},
-        }
-
-    hass.http.register_view(KonnectedView)
-
-    # Check if they have yaml configured devices
-    if CONF_DEVICES not in cfg:
-        return True
-
-    for device in cfg.get(CONF_DEVICES, []):
-        # Attempt to importing the cfg. Use
-        # hass.async_add_job to avoid a deadlock.
-        hass.async_create_task(
-            hass.config_entries.flow.async_init(
-                DOMAIN, context={"source": config_entries.SOURCE_IMPORT}, data=device
-            )
-        )
+    """Set up the Konnected.io integration."""
+    if DOMAIN in config:
+        _create_issue(hass)
     return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up panel from a config entry."""
-    client = AlarmPanel(hass, entry)
-    # creates a panel data store in hass.data[DOMAIN][CONF_DEVICES]
-    await client.async_save_data()
-
-    # if the cfg entry was created we know we could connect to the panel at some point
-    # async_connect will handle retries until it establishes a connection
-    await client.async_connect()
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    entry.async_on_unload(entry.add_update_listener(async_entry_updated))
+    """Set up Konnected.io from a config entry."""
+    _create_issue(hass)
     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 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)
 
-    if unload_ok:
-        hass.data[DOMAIN][CONF_DEVICES].pop(entry.data[CONF_ID])
-
-    return unload_ok
+    return True
 
 
-async def async_entry_updated(hass: HomeAssistant, entry: ConfigEntry) -> None:
-    """Reload the config entry when options change."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
-class KonnectedView(HomeAssistantView):
-    """View creates an endpoint to receive push updates from the device."""
-
-    url = UPDATE_ENDPOINT
-    name = "api:konnected"
-    requires_auth = False  # Uses access token from configuration
-
-    def __init__(self) -> None:
-        """Initialize the view."""
-
-    @staticmethod
-    def binary_value(state, activation):
-        """Return binary value for GPIO based on state and activation."""
-        if activation == STATE_HIGH:
-            return 1 if state == STATE_ON else 0
-        return 0 if state == STATE_ON else 1
-
-    async def update_sensor(self, request: Request, device_id) -> Response:
-        """Process a put or post."""
-        hass = request.app[KEY_HASS]
-        data = hass.data[DOMAIN]
-
-        auth = request.headers.get(AUTHORIZATION)
-        tokens = []
-        if hass.data[DOMAIN].get(CONF_ACCESS_TOKEN):
-            tokens.extend([hass.data[DOMAIN][CONF_ACCESS_TOKEN]])
-        tokens.extend(
-            [
-                entry.data[CONF_ACCESS_TOKEN]
-                for entry in hass.config_entries.async_entries(DOMAIN)
-                if entry.data.get(CONF_ACCESS_TOKEN)
-            ]
-        )
-        if auth is None or not next(
-            (True for token in tokens if hmac.compare_digest(f"Bearer {token}", auth)),
-            False,
-        ):
-            return self.json_message(
-                "unauthorized", status_code=HTTPStatus.UNAUTHORIZED
-            )
-
-        try:  # Konnected 2.2.0 and above supports JSON payloads
-            payload = await request.json()
-        except json.decoder.JSONDecodeError:
-            _LOGGER.error(
-                "Your Konnected device software may be out of "
-                "date. Visit https://help.konnected.io for "
-                "updating instructions"
-            )
-
-        if (device := data[CONF_DEVICES].get(device_id)) is None:
-            return self.json_message(
-                "unregistered device", status_code=HTTPStatus.BAD_REQUEST
-            )
-
-        if (panel := device.get("panel")) is not None:
-            # connect if we haven't already
-            hass.async_create_task(panel.async_connect())
-
-        try:
-            zone_num = str(payload.get(CONF_ZONE) or PIN_TO_ZONE[payload[CONF_PIN]])
-            payload[CONF_ZONE] = zone_num
-            zone_data = (
-                device[CONF_BINARY_SENSORS].get(zone_num)
-                or next(
-                    (s for s in device[CONF_SWITCHES] if s[CONF_ZONE] == zone_num), None
-                )
-                or next(
-                    (s for s in device[CONF_SENSORS] if s[CONF_ZONE] == zone_num), None
-                )
-            )
-        except KeyError:
-            zone_data = None
-
-        if zone_data is None:
-            return self.json_message(
-                "unregistered sensor/actuator", status_code=HTTPStatus.BAD_REQUEST
-            )
-
-        zone_data["device_id"] = device_id
-
-        for attr in ("state", "temp", "humi", "addr"):
-            value = payload.get(attr)
-            handler = HANDLERS.get(attr)
-            if value is not None and handler:
-                hass.async_create_task(handler(hass, zone_data, payload))
-
-        return self.json_message("ok")
-
-    async def get(self, request: Request, device_id) -> Response:
-        """Return the current binary state of a switch."""
-        hass = request.app[KEY_HASS]
-        data = hass.data[DOMAIN]
-
-        if not (device := data[CONF_DEVICES].get(device_id)):
-            return self.json_message(
-                f"Device {device_id} not configured", status_code=HTTPStatus.NOT_FOUND
-            )
-
-        if (panel := device.get("panel")) is not None:
-            # connect if we haven't already
-            hass.async_create_task(panel.async_connect())
-
-        # Our data model is based on zone ids but we convert from/to pin ids
-        # based on whether they are specified in the request
-        try:
-            zone_num = str(
-                request.query.get(CONF_ZONE) or PIN_TO_ZONE[request.query[CONF_PIN]]
-            )
-            zone = next(
-                switch
-                for switch in device[CONF_SWITCHES]
-                if switch[CONF_ZONE] == zone_num
-            )
-
-        except StopIteration:
-            zone = None
-        except KeyError:
-            zone = None
-            zone_num = None
-
-        if not zone:
-            target = request.query.get(
-                CONF_ZONE, request.query.get(CONF_PIN, "unknown")
-            )
-            return self.json_message(
-                f"Switch on zone or pin {target} not configured",
-                status_code=HTTPStatus.NOT_FOUND,
-            )
-
-        resp = {}
-        if request.query.get(CONF_ZONE):
-            resp[CONF_ZONE] = zone_num
-        elif zone_num:
-            resp[CONF_PIN] = ZONE_TO_PIN[zone_num]
-
-        # Make sure entity is setup
-        if zone_entity_id := zone.get(ATTR_ENTITY_ID):
-            resp["state"] = self.binary_value(
-                hass.states.get(zone_entity_id).state,  # type: ignore[union-attr]
-                zone[CONF_ACTIVATION],
-            )
-            return self.json(resp)
-
-        _LOGGER.warning("Konnected entity not yet setup, returning default")
-        resp["state"] = self.binary_value(STATE_OFF, zone[CONF_ACTIVATION])
-        return self.json(resp)
-
-    async def put(self, request: Request, device_id) -> Response:
-        """Receive a sensor update via PUT request and async set state."""
-        return await self.update_sensor(request, device_id)
-
-    async def post(self, request: Request, device_id) -> Response:
-        """Receive a sensor update via POST request and async set state."""
-        return await self.update_sensor(request, device_id)
+def _create_issue(hass: HomeAssistant) -> None:
+    """Create the integration removed repair issue."""
+    ir.async_create_issue(
+        hass,
+        DOMAIN,
+        DOMAIN,
+        is_fixable=False,
+        severity=ir.IssueSeverity.ERROR,
+        translation_key="integration_removed",
+        translation_placeholders={
+            "entries": "/config/integrations/integration/konnected",
+            "kb_page_url": "https://support.konnected.io/migrating-from-konnected-legacy-home-assistant-integration-to-esphome",
+        },
+    )

homeassistant/components/konnected/binary_sensor.py

@@ -1,69 +0,0 @@
-"""Support for wired binary sensors attached to a Konnected device."""
-
-from homeassistant.components.binary_sensor import BinarySensorEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    ATTR_STATE,
-    CONF_BINARY_SENSORS,
-    CONF_DEVICES,
-    CONF_NAME,
-    CONF_TYPE,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import DOMAIN
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up binary sensors attached to a Konnected device from a config entry."""
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=home-assistant-use-runtime-data
-    data = hass.data[DOMAIN]
-    device_id = config_entry.data["id"]
-    sensors = [
-        KonnectedBinarySensor(device_id, pin_num, pin_data)
-        for pin_num, pin_data in data[CONF_DEVICES][device_id][
-            CONF_BINARY_SENSORS
-        ].items()
-    ]
-    async_add_entities(sensors)
-
-
-class KonnectedBinarySensor(BinarySensorEntity):
-    """Representation of a Konnected binary sensor."""
-
-    _attr_should_poll = False
-
-    def __init__(self, device_id, zone_num, data):
-        """Initialize the Konnected binary sensor."""
-        self._data = data
-        self._attr_is_on = data.get(ATTR_STATE)
-        self._attr_device_class = data.get(CONF_TYPE)
-        self._attr_unique_id = f"{device_id}-{zone_num}"
-        self._attr_name = data.get(CONF_NAME)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, device_id)},
-        )
-
-    async def async_added_to_hass(self) -> None:
-        """Store entity_id and register state change callback."""
-        self._data[ATTR_ENTITY_ID] = self.entity_id
-        self.async_on_remove(
-            async_dispatcher_connect(
-                self.hass, f"konnected.{self.entity_id}.update", self.async_set_state
-            )
-        )
-
-    @callback
-    def async_set_state(self, state):
-        """Update the sensor's state."""
-        self._attr_is_on = state
-        self.async_write_ha_state()

homeassistant/components/konnected/config_flow.py

@@ -1,892 +1,11 @@
-"""Config flow for konnected.io integration."""
-# pylint: disable=home-assistant-config-flow-name-field  # Name field is no longer allowed in config flow schemas
+"""Config flow for Konnected.io integration."""
 
-import asyncio
-import copy
-import logging
-import random
-import string
-from typing import Any
-from urllib.parse import urlparse
+from homeassistant.config_entries import ConfigFlow
 
-import voluptuous as vol
-
-from homeassistant.components.binary_sensor import (
-    DEVICE_CLASSES_SCHEMA,
-    BinarySensorDeviceClass,
-)
-from homeassistant.config_entries import (
-    ConfigEntry,
-    ConfigFlow,
-    ConfigFlowResult,
-    OptionsFlow,
-)
-from homeassistant.const import (
-    CONF_ACCESS_TOKEN,
-    CONF_BINARY_SENSORS,
-    CONF_DISCOVERY,
-    CONF_HOST,
-    CONF_ID,
-    CONF_MODEL,
-    CONF_NAME,
-    CONF_PORT,
-    CONF_REPEAT,
-    CONF_SENSORS,
-    CONF_SWITCHES,
-    CONF_TYPE,
-    CONF_ZONE,
-)
-from homeassistant.core import callback
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.service_info.ssdp import (
-    ATTR_UPNP_MANUFACTURER,
-    ATTR_UPNP_MODEL_NAME,
-    SsdpServiceInfo,
-)
-
-from .const import (
-    CONF_ACTIVATION,
-    CONF_API_HOST,
-    CONF_BLINK,
-    CONF_DEFAULT_OPTIONS,
-    CONF_INVERSE,
-    CONF_MOMENTARY,
-    CONF_PAUSE,
-    CONF_POLL_INTERVAL,
-    DOMAIN,
-    STATE_HIGH,
-    STATE_LOW,
-    ZONES,
-)
-from .errors import CannotConnect
-from .panel import KONN_MODEL, KONN_MODEL_PRO, get_status
-
-_LOGGER = logging.getLogger(__name__)
-
-ATTR_KONN_UPNP_MODEL_NAME = "model_name"  # standard upnp is modelName
-CONF_IO = "io"
-CONF_IO_DIS = "Disabled"
-CONF_IO_BIN = "Binary Sensor"
-CONF_IO_DIG = "Digital Sensor"
-CONF_IO_SWI = "Switchable Output"
-
-CONF_MORE_STATES = "more_states"
-CONF_YES = "Yes"
-CONF_NO = "No"
-
-CONF_OVERRIDE_API_HOST = "override_api_host"
-
-KONN_MANUFACTURER = "konnected.io"
-KONN_PANEL_MODEL_NAMES = {
-    KONN_MODEL: "Konnected Alarm Panel",
-    KONN_MODEL_PRO: "Konnected Alarm Panel Pro",
-}
-
-OPTIONS_IO_ANY = vol.In([CONF_IO_DIS, CONF_IO_BIN, CONF_IO_DIG, CONF_IO_SWI])
-OPTIONS_IO_INPUT_ONLY = vol.In([CONF_IO_DIS, CONF_IO_BIN])
-OPTIONS_IO_OUTPUT_ONLY = vol.In([CONF_IO_DIS, CONF_IO_SWI])
-
-
-# Config entry schemas
-IO_SCHEMA = vol.Schema(
-    {
-        vol.Optional("1", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("2", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("3", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("4", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("5", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("6", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("7", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("8", default=CONF_IO_DIS): OPTIONS_IO_ANY,
-        vol.Optional("9", default=CONF_IO_DIS): OPTIONS_IO_INPUT_ONLY,
-        vol.Optional("10", default=CONF_IO_DIS): OPTIONS_IO_INPUT_ONLY,
-        vol.Optional("11", default=CONF_IO_DIS): OPTIONS_IO_INPUT_ONLY,
-        vol.Optional("12", default=CONF_IO_DIS): OPTIONS_IO_INPUT_ONLY,
-        vol.Optional("out", default=CONF_IO_DIS): OPTIONS_IO_OUTPUT_ONLY,
-        vol.Optional("alarm1", default=CONF_IO_DIS): OPTIONS_IO_OUTPUT_ONLY,
-        vol.Optional("out1", default=CONF_IO_DIS): OPTIONS_IO_OUTPUT_ONLY,
-        vol.Optional("alarm2_out2", default=CONF_IO_DIS): OPTIONS_IO_OUTPUT_ONLY,
-    }
-)
-
-BINARY_SENSOR_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_ZONE): vol.In(ZONES),
-        vol.Required(
-            CONF_TYPE, default=BinarySensorDeviceClass.DOOR
-        ): DEVICE_CLASSES_SCHEMA,
-        vol.Optional(CONF_NAME): cv.string,
-        vol.Optional(CONF_INVERSE, default=False): cv.boolean,
-    }
-)
-
-SENSOR_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_ZONE): vol.In(ZONES),
-        vol.Required(CONF_TYPE, default="dht"): vol.All(
-            vol.Lower, vol.In(["dht", "ds18b20"])
-        ),
-        vol.Optional(CONF_NAME): cv.string,
-        vol.Optional(CONF_POLL_INTERVAL, default=3): vol.All(
-            vol.Coerce(int), vol.Range(min=1)
-        ),
-    }
-)
-
-SWITCH_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_ZONE): vol.In(ZONES),
-        vol.Optional(CONF_NAME): cv.string,
-        vol.Optional(CONF_ACTIVATION, default=STATE_HIGH): vol.All(
-            vol.Lower, vol.In([STATE_HIGH, STATE_LOW])
-        ),
-        vol.Optional(CONF_MOMENTARY): vol.All(vol.Coerce(int), vol.Range(min=10)),
-        vol.Optional(CONF_PAUSE): vol.All(vol.Coerce(int), vol.Range(min=10)),
-        vol.Optional(CONF_REPEAT): vol.All(vol.Coerce(int), vol.Range(min=-1)),
-    }
-)
-
-OPTIONS_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_IO): IO_SCHEMA,
-        vol.Optional(CONF_BINARY_SENSORS): vol.All(
-            cv.ensure_list, [BINARY_SENSOR_SCHEMA]
-        ),
-        vol.Optional(CONF_SENSORS): vol.All(cv.ensure_list, [SENSOR_SCHEMA]),
-        vol.Optional(CONF_SWITCHES): vol.All(cv.ensure_list, [SWITCH_SCHEMA]),
-        vol.Optional(CONF_BLINK, default=True): cv.boolean,
-        vol.Optional(CONF_API_HOST, default=""): vol.Any("", cv.url),
-        vol.Optional(CONF_DISCOVERY, default=True): cv.boolean,
-    },
-    extra=vol.REMOVE_EXTRA,
-)
-
-CONFIG_ENTRY_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_ID): cv.matches_regex("[0-9a-f]{12}"),
-        vol.Required(CONF_HOST): cv.string,
-        vol.Required(CONF_PORT): cv.port,
-        vol.Required(CONF_MODEL): vol.Any(*KONN_PANEL_MODEL_NAMES),
-        vol.Required(CONF_ACCESS_TOKEN): cv.matches_regex("[a-zA-Z0-9]+"),
-        vol.Required(CONF_DEFAULT_OPTIONS): OPTIONS_SCHEMA,
-    },
-    extra=vol.REMOVE_EXTRA,
-)
+from .const import DOMAIN
 
 
 class KonnectedFlowHandler(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Konnected Panels."""
+    """Handle a config flow for Konnected.io."""
 
     VERSION = 1
-
-    # class variable to store/share discovered host information
-    DISCOVERED_HOSTS: dict[str, dict[str, Any]] = {}
-
-    unique_id: str
-
-    def __init__(self) -> None:
-        """Initialize the Konnected flow."""
-        self.data: dict[str, Any] = {}
-        self.options = OPTIONS_SCHEMA({CONF_IO: {}})
-
-    async def async_gen_config(self, host, port):
-        """Populate self.data based on panel status.
-
-        This will raise CannotConnect if an error occurs
-        """
-        self.data[CONF_HOST] = host
-        self.data[CONF_PORT] = port
-        try:
-            status = await get_status(self.hass, host, port)
-            self.data[CONF_ID] = status.get("chipId", status["mac"].replace(":", ""))
-        except (CannotConnect, KeyError) as err:
-            raise CannotConnect from err
-
-        self.data[CONF_MODEL] = status.get("model", KONN_MODEL)
-        self.data[CONF_ACCESS_TOKEN] = "".join(
-            random.choices(f"{string.ascii_uppercase}{string.digits}", k=20)
-        )
-
-    async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
-        """Import a configuration.yaml config.
-
-        This flow is triggered by `async_setup` for configured panels.
-        """
-        _LOGGER.debug(import_data)
-
-        # save the data and confirm connection via user step
-        await self.async_set_unique_id(import_data["id"])
-        self.options = import_data[CONF_DEFAULT_OPTIONS]
-
-        # config schema ensures we have port if we have host
-        if import_data.get(CONF_HOST):
-            # automatically connect if we have host info
-            return await self.async_step_user(
-                user_input={
-                    CONF_HOST: import_data[CONF_HOST],
-                    CONF_PORT: import_data[CONF_PORT],
-                }
-            )
-
-        # if we have no host info wait for it or abort if previously configured
-        self._abort_if_unique_id_configured()
-        return await self.async_step_import_confirm()
-
-    async def async_step_import_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Confirm the user wants to import the config entry."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="import_confirm",
-                description_placeholders={"id": self.unique_id},
-            )
-
-        # if we have ssdp discovered applicable host info use it
-        if KonnectedFlowHandler.DISCOVERED_HOSTS.get(self.unique_id):
-            return await self.async_step_user(
-                user_input={
-                    CONF_HOST: KonnectedFlowHandler.DISCOVERED_HOSTS[self.unique_id][
-                        CONF_HOST
-                    ],
-                    CONF_PORT: KonnectedFlowHandler.DISCOVERED_HOSTS[self.unique_id][
-                        CONF_PORT
-                    ],
-                }
-            )
-        return await self.async_step_user()
-
-    async def async_step_ssdp(
-        self, discovery_info: SsdpServiceInfo
-    ) -> ConfigFlowResult:
-        """Handle a discovered konnected panel.
-
-        This flow is triggered by the SSDP component. It will check if the
-        device is already configured and attempt to finish the config if not.
-        """
-        _LOGGER.debug(discovery_info)
-
-        try:
-            if discovery_info.upnp[ATTR_UPNP_MANUFACTURER] != KONN_MANUFACTURER:
-                return self.async_abort(reason="not_konn_panel")
-
-            if not any(
-                name in discovery_info.upnp[ATTR_UPNP_MODEL_NAME]
-                for name in KONN_PANEL_MODEL_NAMES
-            ):
-                _LOGGER.warning(
-                    "Discovered unrecognized Konnected device %s",
-                    discovery_info.upnp.get(ATTR_UPNP_MODEL_NAME, "Unknown"),
-                )
-                return self.async_abort(reason="not_konn_panel")
-
-        # If MAC is missing it is a bug in the device fw but we'll guard
-        # against it since the field is so vital
-        except KeyError:
-            _LOGGER.error("Malformed Konnected SSDP info")
-        else:
-            # extract host/port from ssdp_location
-            assert discovery_info.ssdp_location
-            netloc = urlparse(discovery_info.ssdp_location).netloc.split(":")
-            self._async_abort_entries_match(
-                {CONF_HOST: netloc[0], CONF_PORT: int(netloc[1])}
-            )
-
-            try:
-                status = await get_status(self.hass, netloc[0], int(netloc[1]))
-            except CannotConnect:
-                return self.async_abort(reason="cannot_connect")
-
-            self.data[CONF_HOST] = netloc[0]
-            self.data[CONF_PORT] = int(netloc[1])
-            self.data[CONF_ID] = status.get("chipId", status["mac"].replace(":", ""))
-            self.data[CONF_MODEL] = status.get("model", KONN_MODEL)
-
-            KonnectedFlowHandler.DISCOVERED_HOSTS[self.data[CONF_ID]] = {
-                CONF_HOST: self.data[CONF_HOST],
-                CONF_PORT: self.data[CONF_PORT],
-            }
-            return await self.async_step_confirm()
-
-        return self.async_abort(reason="unknown")
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Connect to panel and get config."""
-        errors = {}
-        if user_input:
-            # build config info and wait for user confirmation
-            self.data[CONF_HOST] = user_input[CONF_HOST]
-            self.data[CONF_PORT] = user_input[CONF_PORT]
-
-            # brief delay to allow processing of recent status req
-            await asyncio.sleep(0.1)
-            try:
-                status = await get_status(
-                    self.hass, self.data[CONF_HOST], self.data[CONF_PORT]
-                )
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            else:
-                self.data[CONF_ID] = status.get(
-                    "chipId", status["mac"].replace(":", "")
-                )
-                self.data[CONF_MODEL] = status.get("model", KONN_MODEL)
-
-                # save off our discovered host info
-                KonnectedFlowHandler.DISCOVERED_HOSTS[self.data[CONF_ID]] = {
-                    CONF_HOST: self.data[CONF_HOST],
-                    CONF_PORT: self.data[CONF_PORT],
-                }
-                return await self.async_step_confirm()
-
-        return self.async_show_form(
-            step_id="user",
-            description_placeholders={
-                "host": self.data.get(CONF_HOST, "Unknown"),
-                "port": self.data.get(CONF_PORT, "Unknown"),
-            },
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_HOST, default=self.data.get(CONF_HOST)): str,
-                    vol.Required(CONF_PORT, default=self.data.get(CONF_PORT)): int,
-                }
-            ),
-            errors=errors,
-        )
-
-    async def async_step_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Attempt to link with the Konnected panel.
-
-        Given a configured host, will ask the user to confirm and finalize
-        the connection.
-        """
-        if user_input is None:
-            # abort and update an existing config entry if host info changes
-            await self.async_set_unique_id(self.data[CONF_ID])
-            self._abort_if_unique_id_configured(
-                updates=self.data, reload_on_update=False
-            )
-            return self.async_show_form(
-                step_id="confirm",
-                description_placeholders={
-                    "model": KONN_PANEL_MODEL_NAMES[self.data[CONF_MODEL]],
-                    "id": self.unique_id,
-                    "host": self.data[CONF_HOST],
-                    "port": self.data[CONF_PORT],
-                },
-            )
-
-        # Create access token, attach default options and create entry
-        self.data[CONF_DEFAULT_OPTIONS] = self.options
-        self.data[CONF_ACCESS_TOKEN] = self.hass.data.get(DOMAIN, {}).get(
-            CONF_ACCESS_TOKEN
-        ) or "".join(random.choices(f"{string.ascii_uppercase}{string.digits}", k=20))
-
-        return self.async_create_entry(
-            title=KONN_PANEL_MODEL_NAMES[self.data[CONF_MODEL]],
-            data=self.data,
-        )
-
-    @staticmethod
-    @callback
-    def async_get_options_flow(
-        config_entry: ConfigEntry,
-    ) -> OptionsFlowHandler:
-        """Return the Options Flow."""
-        return OptionsFlowHandler(config_entry)
-
-
-class OptionsFlowHandler(OptionsFlow):
-    """Handle a option flow for a Konnected Panel."""
-
-    def __init__(self, config_entry: ConfigEntry) -> None:
-        """Initialize options flow."""
-        self.model = config_entry.data[CONF_MODEL]
-        self.current_opt = (
-            config_entry.options or config_entry.data[CONF_DEFAULT_OPTIONS]
-        )
-
-        # as config proceeds we'll build up new options
-        # and then replace what's in the config entry
-        self.new_opt: dict[str, Any] = {CONF_IO: {}}
-        self.active_cfg: str | None = None
-        self.io_cfg: dict[str, Any] = {}
-        self.current_states: list[dict[str, Any]] = []
-        self.current_state = 1
-
-    @callback
-    def get_current_cfg(self, io_type, zone):
-        """Get the current zone config."""
-        return next(
-            (
-                cfg
-                for cfg in self.current_opt.get(io_type, [])
-                if cfg[CONF_ZONE] == zone
-            ),
-            {},
-        )
-
-    async def async_step_init(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle options flow."""
-        return await self.async_step_options_io()
-
-    async def async_step_options_io(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Configure legacy panel IO or first half of pro IO."""
-        errors: dict[str, str] = {}
-        current_io = self.current_opt.get(CONF_IO, {})
-
-        if user_input is not None:
-            # strip out disabled io and save for options cfg
-            for key, value in user_input.items():
-                if value != CONF_IO_DIS:
-                    self.new_opt[CONF_IO][key] = value
-            return await self.async_step_options_io_ext()
-
-        if self.model == KONN_MODEL:
-            return self.async_show_form(
-                step_id="options_io",
-                data_schema=vol.Schema(
-                    {
-                        vol.Required(
-                            "1", default=current_io.get("1", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "2", default=current_io.get("2", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "3", default=current_io.get("3", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "4", default=current_io.get("4", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "5", default=current_io.get("5", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "6", default=current_io.get("6", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "out", default=current_io.get("out", CONF_IO_DIS)
-                        ): OPTIONS_IO_OUTPUT_ONLY,
-                    }
-                ),
-                description_placeholders={
-                    "model": KONN_PANEL_MODEL_NAMES[self.model],
-                    "host": self.config_entry.data[CONF_HOST],
-                },
-                errors=errors,
-            )
-
-        # configure the first half of the pro board io
-        if self.model == KONN_MODEL_PRO:
-            return self.async_show_form(
-                step_id="options_io",
-                data_schema=vol.Schema(
-                    {
-                        vol.Required(
-                            "1", default=current_io.get("1", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "2", default=current_io.get("2", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "3", default=current_io.get("3", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "4", default=current_io.get("4", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "5", default=current_io.get("5", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "6", default=current_io.get("6", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "7", default=current_io.get("7", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                    }
-                ),
-                description_placeholders={
-                    "model": KONN_PANEL_MODEL_NAMES[self.model],
-                    "host": self.config_entry.data[CONF_HOST],
-                },
-                errors=errors,
-            )
-
-        return self.async_abort(reason="not_konn_panel")
-
-    async def async_step_options_io_ext(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Allow the user to configure the extended IO for pro."""
-        errors: dict[str, str] = {}
-        current_io = self.current_opt.get(CONF_IO, {})
-
-        if user_input is not None:
-            # strip out disabled io and save for options cfg
-            for key, value in user_input.items():
-                if value != CONF_IO_DIS:
-                    self.new_opt[CONF_IO].update({key: value})
-            self.io_cfg = copy.deepcopy(self.new_opt[CONF_IO])
-            return await self.async_step_options_binary()
-
-        if self.model == KONN_MODEL:
-            self.io_cfg = copy.deepcopy(self.new_opt[CONF_IO])
-            return await self.async_step_options_binary()
-
-        if self.model == KONN_MODEL_PRO:
-            return self.async_show_form(
-                step_id="options_io_ext",
-                data_schema=vol.Schema(
-                    {
-                        vol.Required(
-                            "8", default=current_io.get("8", CONF_IO_DIS)
-                        ): OPTIONS_IO_ANY,
-                        vol.Required(
-                            "9", default=current_io.get("9", CONF_IO_DIS)
-                        ): OPTIONS_IO_INPUT_ONLY,
-                        vol.Required(
-                            "10", default=current_io.get("10", CONF_IO_DIS)
-                        ): OPTIONS_IO_INPUT_ONLY,
-                        vol.Required(
-                            "11", default=current_io.get("11", CONF_IO_DIS)
-                        ): OPTIONS_IO_INPUT_ONLY,
-                        vol.Required(
-                            "12", default=current_io.get("12", CONF_IO_DIS)
-                        ): OPTIONS_IO_INPUT_ONLY,
-                        vol.Required(
-                            "alarm1", default=current_io.get("alarm1", CONF_IO_DIS)
-                        ): OPTIONS_IO_OUTPUT_ONLY,
-                        vol.Required(
-                            "out1", default=current_io.get("out1", CONF_IO_DIS)
-                        ): OPTIONS_IO_OUTPUT_ONLY,
-                        vol.Required(
-                            "alarm2_out2",
-                            default=current_io.get("alarm2_out2", CONF_IO_DIS),
-                        ): OPTIONS_IO_OUTPUT_ONLY,
-                    }
-                ),
-                description_placeholders={
-                    "model": KONN_PANEL_MODEL_NAMES[self.model],
-                    "host": self.config_entry.data[CONF_HOST],
-                },
-                errors=errors,
-            )
-
-        return self.async_abort(reason="not_konn_panel")
-
-    async def async_step_options_binary(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Allow the user to configure the IO options for binary sensors."""
-        errors: dict[str, str] = {}
-        if user_input is not None and self.active_cfg is not None:
-            zone = {"zone": self.active_cfg}
-            zone.update(user_input)
-            self.new_opt[CONF_BINARY_SENSORS] = [
-                *self.new_opt.get(CONF_BINARY_SENSORS, []),
-                zone,
-            ]
-            self.io_cfg.pop(self.active_cfg)
-            self.active_cfg = None
-
-        if self.active_cfg:
-            current_cfg = self.get_current_cfg(CONF_BINARY_SENSORS, self.active_cfg)
-            return self.async_show_form(
-                step_id="options_binary",
-                data_schema=vol.Schema(
-                    {
-                        vol.Required(
-                            CONF_TYPE,
-                            default=current_cfg.get(
-                                CONF_TYPE, BinarySensorDeviceClass.DOOR
-                            ),
-                        ): DEVICE_CLASSES_SCHEMA,
-                        vol.Optional(
-                            CONF_NAME, default=current_cfg.get(CONF_NAME, vol.UNDEFINED)
-                        ): str,
-                        vol.Optional(
-                            CONF_INVERSE, default=current_cfg.get(CONF_INVERSE, False)
-                        ): bool,
-                    }
-                ),
-                description_placeholders={
-                    "zone": f"Zone {self.active_cfg}"
-                    if len(self.active_cfg) < 3
-                    else self.active_cfg.upper()
-                },
-                errors=errors,
-            )
-
-        # find the next unconfigured binary sensor
-        for key, value in self.io_cfg.items():
-            if value == CONF_IO_BIN:
-                self.active_cfg = key
-                current_cfg = self.get_current_cfg(CONF_BINARY_SENSORS, self.active_cfg)
-                return self.async_show_form(
-                    step_id="options_binary",
-                    data_schema=vol.Schema(
-                        {
-                            vol.Required(
-                                CONF_TYPE,
-                                default=current_cfg.get(
-                                    CONF_TYPE, BinarySensorDeviceClass.DOOR
-                                ),
-                            ): DEVICE_CLASSES_SCHEMA,
-                            vol.Optional(
-                                CONF_NAME,
-                                default=current_cfg.get(CONF_NAME, vol.UNDEFINED),
-                            ): str,
-                            vol.Optional(
-                                CONF_INVERSE,
-                                default=current_cfg.get(CONF_INVERSE, False),
-                            ): bool,
-                        }
-                    ),
-                    description_placeholders={
-                        "zone": f"Zone {self.active_cfg}"
-                        if len(self.active_cfg) < 3
-                        else self.active_cfg.upper()
-                    },
-                    errors=errors,
-                )
-
-        return await self.async_step_options_digital()
-
-    async def async_step_options_digital(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Allow the user to configure the IO options for digital sensors."""
-        errors: dict[str, str] = {}
-        if user_input is not None and self.active_cfg is not None:
-            zone = {"zone": self.active_cfg}
-            zone.update(user_input)
-            self.new_opt[CONF_SENSORS] = [*self.new_opt.get(CONF_SENSORS, []), zone]
-            self.io_cfg.pop(self.active_cfg)
-            self.active_cfg = None
-
-        if self.active_cfg:
-            current_cfg = self.get_current_cfg(CONF_SENSORS, self.active_cfg)
-            return self.async_show_form(
-                step_id="options_digital",
-                data_schema=vol.Schema(
-                    {
-                        vol.Required(
-                            CONF_TYPE, default=current_cfg.get(CONF_TYPE, "dht")
-                        ): vol.All(vol.Lower, vol.In(["dht", "ds18b20"])),
-                        vol.Optional(
-                            CONF_NAME, default=current_cfg.get(CONF_NAME, vol.UNDEFINED)
-                        ): str,
-                        vol.Optional(
-                            CONF_POLL_INTERVAL,
-                            default=current_cfg.get(CONF_POLL_INTERVAL, 3),
-                        ): vol.All(vol.Coerce(int), vol.Range(min=1)),
-                    }
-                ),
-                description_placeholders={
-                    "zone": f"Zone {self.active_cfg}"
-                    if len(self.active_cfg) < 3
-                    else self.active_cfg.upper()
-                },
-                errors=errors,
-            )
-
-        # find the next unconfigured digital sensor
-        for key, value in self.io_cfg.items():
-            if value == CONF_IO_DIG:
-                self.active_cfg = key
-                current_cfg = self.get_current_cfg(CONF_SENSORS, self.active_cfg)
-                return self.async_show_form(
-                    step_id="options_digital",
-                    data_schema=vol.Schema(
-                        {
-                            vol.Required(
-                                CONF_TYPE, default=current_cfg.get(CONF_TYPE, "dht")
-                            ): vol.All(vol.Lower, vol.In(["dht", "ds18b20"])),
-                            vol.Optional(
-                                CONF_NAME,
-                                default=current_cfg.get(CONF_NAME, vol.UNDEFINED),
-                            ): str,
-                            vol.Optional(
-                                CONF_POLL_INTERVAL,
-                                default=current_cfg.get(CONF_POLL_INTERVAL, 3),
-                            ): vol.All(vol.Coerce(int), vol.Range(min=1)),
-                        }
-                    ),
-                    description_placeholders={
-                        "zone": f"Zone {self.active_cfg}"
-                        if len(self.active_cfg) < 3
-                        else self.active_cfg.upper()
-                    },
-                    errors=errors,
-                )
-
-        return await self.async_step_options_switch()
-
-    async def async_step_options_switch(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Allow the user to configure the IO options for switches."""
-        errors: dict[str, str] = {}
-        if user_input is not None and self.active_cfg is not None:
-            zone = {"zone": self.active_cfg}
-            zone.update(user_input)
-            del zone[CONF_MORE_STATES]
-            self.new_opt[CONF_SWITCHES] = [*self.new_opt.get(CONF_SWITCHES, []), zone]
-
-            # iterate through multiple switch states
-            if self.current_states:
-                self.current_states.pop(0)
-
-            # only go to next zone if all states are entered
-            self.current_state += 1
-            if user_input[CONF_MORE_STATES] == CONF_NO:
-                self.io_cfg.pop(self.active_cfg)
-                self.active_cfg = None
-
-        if self.active_cfg:
-            current_cfg = next(iter(self.current_states), {})
-            return self.async_show_form(
-                step_id="options_switch",
-                data_schema=vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_NAME, default=current_cfg.get(CONF_NAME, vol.UNDEFINED)
-                        ): str,
-                        vol.Optional(
-                            CONF_ACTIVATION,
-                            default=current_cfg.get(CONF_ACTIVATION, STATE_HIGH),
-                        ): vol.All(vol.Lower, vol.In([STATE_HIGH, STATE_LOW])),
-                        vol.Optional(
-                            CONF_MOMENTARY,
-                            default=current_cfg.get(CONF_MOMENTARY, vol.UNDEFINED),
-                        ): vol.All(vol.Coerce(int), vol.Range(min=10)),
-                        vol.Optional(
-                            CONF_PAUSE,
-                            default=current_cfg.get(CONF_PAUSE, vol.UNDEFINED),
-                        ): vol.All(vol.Coerce(int), vol.Range(min=10)),
-                        vol.Optional(
-                            CONF_REPEAT,
-                            default=current_cfg.get(CONF_REPEAT, vol.UNDEFINED),
-                        ): vol.All(vol.Coerce(int), vol.Range(min=-1)),
-                        vol.Required(
-                            CONF_MORE_STATES,
-                            default=CONF_YES
-                            if len(self.current_states) > 1
-                            else CONF_NO,
-                        ): vol.In([CONF_YES, CONF_NO]),
-                    }
-                ),
-                description_placeholders={
-                    "zone": f"Zone {self.active_cfg}"
-                    if len(self.active_cfg) < 3
-                    else self.active_cfg.upper(),
-                    "state": str(self.current_state),
-                },
-                errors=errors,
-            )
-
-        # find the next unconfigured switch
-        for key, value in self.io_cfg.items():
-            if value == CONF_IO_SWI:
-                self.active_cfg = key
-                self.current_states = [
-                    cfg
-                    for cfg in self.current_opt.get(CONF_SWITCHES, [])
-                    if cfg[CONF_ZONE] == self.active_cfg
-                ]
-                current_cfg = next(iter(self.current_states), {})
-                self.current_state = 1
-                return self.async_show_form(
-                    step_id="options_switch",
-                    data_schema=vol.Schema(
-                        {
-                            vol.Optional(
-                                CONF_NAME,
-                                default=current_cfg.get(CONF_NAME, vol.UNDEFINED),
-                            ): str,
-                            vol.Optional(
-                                CONF_ACTIVATION,
-                                default=current_cfg.get(CONF_ACTIVATION, STATE_HIGH),
-                            ): vol.In(["low", "high"]),
-                            vol.Optional(
-                                CONF_MOMENTARY,
-                                default=current_cfg.get(CONF_MOMENTARY, vol.UNDEFINED),
-                            ): vol.All(vol.Coerce(int), vol.Range(min=10)),
-                            vol.Optional(
-                                CONF_PAUSE,
-                                default=current_cfg.get(CONF_PAUSE, vol.UNDEFINED),
-                            ): vol.All(vol.Coerce(int), vol.Range(min=10)),
-                            vol.Optional(
-                                CONF_REPEAT,
-                                default=current_cfg.get(CONF_REPEAT, vol.UNDEFINED),
-                            ): vol.All(vol.Coerce(int), vol.Range(min=-1)),
-                            vol.Required(
-                                CONF_MORE_STATES,
-                                default=CONF_YES
-                                if len(self.current_states) > 1
-                                else CONF_NO,
-                            ): vol.In([CONF_YES, CONF_NO]),
-                        }
-                    ),
-                    description_placeholders={
-                        "zone": f"Zone {self.active_cfg}"
-                        if len(self.active_cfg) < 3
-                        else self.active_cfg.upper(),
-                        "state": str(self.current_state),
-                    },
-                    errors=errors,
-                )
-
-        return await self.async_step_options_misc()
-
-    async def async_step_options_misc(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Allow the user to configure the LED behavior."""
-        errors = {}
-        if user_input is not None:
-            # config schema only does basic schema val so check url here
-            try:
-                if user_input[CONF_OVERRIDE_API_HOST]:
-                    cv.url(user_input.get(CONF_API_HOST, ""))
-                else:
-                    user_input[CONF_API_HOST] = ""
-            except vol.Invalid:
-                errors["base"] = "bad_host"
-            else:
-                # no need to store the override - can infer
-                del user_input[CONF_OVERRIDE_API_HOST]
-                self.new_opt.update(user_input)
-                return self.async_create_entry(title="", data=self.new_opt)
-
-        return self.async_show_form(
-            step_id="options_misc",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_DISCOVERY,
-                        default=self.current_opt.get(CONF_DISCOVERY, True),
-                    ): bool,
-                    vol.Required(
-                        CONF_BLINK, default=self.current_opt.get(CONF_BLINK, True)
-                    ): bool,
-                    vol.Required(
-                        CONF_OVERRIDE_API_HOST,
-                        default=bool(self.current_opt.get(CONF_API_HOST)),
-                    ): bool,
-                    vol.Optional(
-                        CONF_API_HOST, default=self.current_opt.get(CONF_API_HOST, "")
-                    ): str,
-                }
-            ),
-            errors=errors,
-        )

homeassistant/components/konnected/const.py

@@ -1,46 +1,3 @@
 """Konnected constants."""
 
 DOMAIN = "konnected"
-
-CONF_ACTIVATION = "activation"
-CONF_API_HOST = "api_host"
-CONF_DEFAULT_OPTIONS = "default_options"
-CONF_MOMENTARY = "momentary"
-CONF_PAUSE = "pause"
-CONF_POLL_INTERVAL = "poll_interval"
-CONF_PRECISION = "precision"
-CONF_INVERSE = "inverse"
-CONF_BLINK = "blink"
-CONF_DHT_SENSORS = "dht_sensors"
-CONF_DS18B20_SENSORS = "ds18b20_sensors"
-
-STATE_LOW = "low"
-STATE_HIGH = "high"
-
-ZONES = [
-    "1",
-    "2",
-    "3",
-    "4",
-    "5",
-    "6",
-    "7",
-    "8",
-    "9",
-    "10",
-    "11",
-    "12",
-    "alarm1",
-    "out1",
-    "alarm2_out2",
-    "out",
-]
-
-# alarm panel pro only handles zones,
-# alarm panel allows specifying pins via configuration.yaml
-PIN_TO_ZONE = {"1": "1", "2": "2", "5": "3", "6": "4", "7": "5", "8": "out", "9": "6"}
-ZONE_TO_PIN = {zone: pin for pin, zone in PIN_TO_ZONE.items()}
-
-ENDPOINT_ROOT = "/api/konnected"
-UPDATE_ENDPOINT = ENDPOINT_ROOT + r"/device/{device_id:[a-zA-Z0-9]+}"
-SIGNAL_DS18B20_NEW = "konnected.ds18b20.new"

homeassistant/components/konnected/errors.py

@@ -1,11 +0,0 @@
-"""Errors for the Konnected component."""
-
-from homeassistant.exceptions import HomeAssistantError
-
-
-class KonnectedException(HomeAssistantError):
-    """Base class for Konnected exceptions."""
-
-
-class CannotConnect(KonnectedException):
-    """Unable to connect to the panel."""

homeassistant/components/konnected/handlers.py

@@ -1,57 +0,0 @@
-"""Handle Konnected messages."""
-
-import logging
-
-from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import ATTR_ENTITY_ID, ATTR_STATE
-from homeassistant.helpers.dispatcher import async_dispatcher_send
-from homeassistant.util import decorator
-
-from .const import CONF_INVERSE, SIGNAL_DS18B20_NEW
-
-_LOGGER = logging.getLogger(__name__)
-HANDLERS = decorator.Registry()  # type: ignore[var-annotated]
-
-
-@HANDLERS.register("state")
-async def async_handle_state_update(hass, context, msg):
-    """Handle a binary sensor or switch state update."""
-    _LOGGER.debug("[state handler] context: %s  msg: %s", context, msg)
-    entity_id = context.get(ATTR_ENTITY_ID)
-    state = bool(int(msg.get(ATTR_STATE)))
-    if context.get(CONF_INVERSE):
-        state = not state
-
-    async_dispatcher_send(hass, f"konnected.{entity_id}.update", state)
-
-
-@HANDLERS.register("temp")
-async def async_handle_temp_update(hass, context, msg):
-    """Handle a temperature sensor state update."""
-    _LOGGER.debug("[temp handler] context: %s  msg: %s", context, msg)
-    entity_id, temp = context.get(SensorDeviceClass.TEMPERATURE), msg.get("temp")
-    if entity_id:
-        async_dispatcher_send(hass, f"konnected.{entity_id}.update", temp)
-
-
-@HANDLERS.register("humi")
-async def async_handle_humi_update(hass, context, msg):
-    """Handle a humidity sensor state update."""
-    _LOGGER.debug("[humi handler] context: %s  msg: %s", context, msg)
-    entity_id, humi = context.get(SensorDeviceClass.HUMIDITY), msg.get("humi")
-    if entity_id:
-        async_dispatcher_send(hass, f"konnected.{entity_id}.update", humi)
-
-
-@HANDLERS.register("addr")
-async def async_handle_addr_update(hass, context, msg):
-    """Handle an addressable sensor update."""
-    _LOGGER.debug("[addr handler] context: %s  msg: %s", context, msg)
-    addr, temp = msg.get("addr"), msg.get("temp")
-    if entity_id := context.get(addr):
-        async_dispatcher_send(hass, f"konnected.{entity_id}.update", temp)
-    else:
-        msg["device_id"] = context.get("device_id")
-        msg["temperature"] = temp
-        msg["addr"] = addr
-        async_dispatcher_send(hass, SIGNAL_DS18B20_NEW, msg)

homeassistant/components/konnected/manifest.json

@@ -1,17 +1,9 @@
 {
   "domain": "konnected",
   "name": "Konnected.io (Legacy)",
-  "codeowners": ["@heythisisnate"],
-  "config_flow": true,
-  "dependencies": ["http"],
+  "codeowners": [],
   "documentation": "https://www.home-assistant.io/integrations/konnected",
-  "integration_type": "hub",
+  "integration_type": "system",
   "iot_class": "local_push",
-  "loggers": ["konnected"],
-  "requirements": ["konnected==1.2.0"],
-  "ssdp": [
-    {
-      "manufacturer": "konnected.io"
-    }
-  ]
+  "requirements": []
 }

homeassistant/components/konnected/panel.py

@@ -1,398 +0,0 @@
-"""Support for Konnected devices."""
-# pylint: disable=home-assistant-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern
-
-import asyncio
-import logging
-
-import konnected
-
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    ATTR_STATE,
-    CONF_ACCESS_TOKEN,
-    CONF_BINARY_SENSORS,
-    CONF_DEVICES,
-    CONF_DISCOVERY,
-    CONF_HOST,
-    CONF_ID,
-    CONF_NAME,
-    CONF_PIN,
-    CONF_PORT,
-    CONF_REPEAT,
-    CONF_SENSORS,
-    CONF_SWITCHES,
-    CONF_TYPE,
-    CONF_ZONE,
-)
-from homeassistant.core import callback
-from homeassistant.helpers import aiohttp_client, device_registry as dr
-from homeassistant.helpers.dispatcher import async_dispatcher_send
-from homeassistant.helpers.event import async_call_later
-from homeassistant.helpers.network import get_url
-
-from .const import (
-    CONF_ACTIVATION,
-    CONF_API_HOST,
-    CONF_BLINK,
-    CONF_DEFAULT_OPTIONS,
-    CONF_DHT_SENSORS,
-    CONF_DS18B20_SENSORS,
-    CONF_INVERSE,
-    CONF_MOMENTARY,
-    CONF_PAUSE,
-    CONF_POLL_INTERVAL,
-    DOMAIN,
-    ENDPOINT_ROOT,
-    STATE_LOW,
-    ZONE_TO_PIN,
-)
-from .errors import CannotConnect
-
-_LOGGER = logging.getLogger(__name__)
-
-KONN_MODEL = "Konnected"
-KONN_MODEL_PRO = "Konnected Pro"
-
-# Indicate how each unit is controlled (pin or zone)
-KONN_API_VERSIONS = {
-    KONN_MODEL: CONF_PIN,
-    KONN_MODEL_PRO: CONF_ZONE,
-}
-
-
-class AlarmPanel:
-    """A representation of a Konnected alarm panel."""
-
-    def __init__(self, hass, config_entry):
-        """Initialize the Konnected device."""
-        self.hass = hass
-        self.config_entry = config_entry
-        self.config = config_entry.data
-        self.options = config_entry.options or config_entry.data.get(
-            CONF_DEFAULT_OPTIONS, {}
-        )
-        self.host = self.config.get(CONF_HOST)
-        self.port = self.config.get(CONF_PORT)
-        self.client = None
-        self.status = None
-        self.api_version = KONN_API_VERSIONS[KONN_MODEL]
-        self.connected = False
-        self.connect_attempts = 0
-        self.cancel_connect_retry = None
-
-    @property
-    def device_id(self):
-        """Device id is the chipId (pro) or MAC address as string."""
-        return self.config.get(CONF_ID)
-
-    @property
-    def stored_configuration(self):
-        """Return the configuration stored in `hass.data` for this device."""
-        return self.hass.data[DOMAIN][CONF_DEVICES].get(self.device_id)
-
-    @property
-    def available(self):
-        """Return whether the device is available."""
-        return self.connected
-
-    def format_zone(self, zone, other_items=None):
-        """Get zone or pin based dict based on the client type."""
-        payload = {
-            self.api_version: zone
-            if self.api_version == CONF_ZONE
-            else ZONE_TO_PIN[zone]
-        }
-        payload.update(other_items or {})
-        return payload
-
-    async def async_connect(self, now=None):
-        """Connect to and setup a Konnected device."""
-        if self.connected:
-            return
-
-        if self.cancel_connect_retry:
-            # cancel any pending connect attempt and try now
-            self.cancel_connect_retry()
-
-        try:
-            self.client = konnected.Client(
-                host=self.host,
-                port=str(self.port),
-                websession=aiohttp_client.async_get_clientsession(self.hass),
-            )
-            self.status = await self.client.get_status()
-            self.api_version = KONN_API_VERSIONS.get(
-                self.status.get("model", KONN_MODEL), KONN_API_VERSIONS[KONN_MODEL]
-            )
-            _LOGGER.debug(
-                "Connected to new %s device", self.status.get("model", "Konnected")
-            )
-            _LOGGER.debug(self.status)
-
-            await self.async_update_initial_states()
-            # brief delay to allow processing of recent status req
-            await asyncio.sleep(0.1)
-            await self.async_sync_device_config()
-
-        except self.client.ClientError as err:
-            _LOGGER.warning("Exception trying to connect to panel: %s", err)
-
-            # retry in a bit, never more than ~3 min
-            self.connect_attempts += 1
-            self.cancel_connect_retry = async_call_later(
-                self.hass, 2 ** min(self.connect_attempts, 5) * 5, self.async_connect
-            )
-            return
-
-        self.connect_attempts = 0
-        self.connected = True
-        _LOGGER.debug(
-            (
-                "Set up Konnected device %s. Open http://%s:%s in a "
-                "web browser to view device status"
-            ),
-            self.device_id,
-            self.host,
-            self.port,
-        )
-
-        device_registry = dr.async_get(self.hass)
-        device_registry.async_get_or_create(
-            config_entry_id=self.config_entry.entry_id,
-            connections={(dr.CONNECTION_NETWORK_MAC, self.status.get("mac"))},
-            identifiers={(DOMAIN, self.device_id)},
-            manufacturer="Konnected.io",
-            name=self.config_entry.title,
-            model=self.config_entry.title,
-            sw_version=self.status.get("swVersion"),
-        )
-
-    async def update_switch(self, zone, state, momentary=None, times=None, pause=None):
-        """Update the state of a switchable output."""
-        try:
-            if self.client:
-                if self.api_version == CONF_ZONE:
-                    return await self.client.put_zone(
-                        zone,
-                        state,
-                        momentary,
-                        times,
-                        pause,
-                    )
-
-                # device endpoint uses pin number instead of zone
-                return await self.client.put_device(
-                    ZONE_TO_PIN[zone],
-                    state,
-                    momentary,
-                    times,
-                    pause,
-                )
-
-        except self.client.ClientError as err:
-            _LOGGER.warning("Exception trying to update panel: %s", err)
-
-        raise CannotConnect
-
-    async def async_save_data(self):
-        """Save the device configuration to `hass.data`."""
-        binary_sensors = {}
-        for entity in self.options.get(CONF_BINARY_SENSORS) or []:
-            zone = entity[CONF_ZONE]
-
-            binary_sensors[zone] = {
-                CONF_TYPE: entity[CONF_TYPE],
-                CONF_NAME: entity.get(
-                    CONF_NAME, f"Konnected {self.device_id[6:]} Zone {zone}"
-                ),
-                CONF_INVERSE: entity.get(CONF_INVERSE),
-                ATTR_STATE: None,
-            }
-            _LOGGER.debug(
-                "Set up binary_sensor %s (initial state: %s)",
-                binary_sensors[zone].get("name"),
-                binary_sensors[zone].get(ATTR_STATE),
-            )
-
-        actuators = []
-        for entity in self.options.get(CONF_SWITCHES) or []:
-            zone = entity[CONF_ZONE]
-
-            act = {
-                CONF_ZONE: zone,
-                CONF_NAME: entity.get(
-                    CONF_NAME,
-                    f"Konnected {self.device_id[6:]} Actuator {zone}",
-                ),
-                ATTR_STATE: None,
-                CONF_ACTIVATION: entity[CONF_ACTIVATION],
-                CONF_MOMENTARY: entity.get(CONF_MOMENTARY),
-                CONF_PAUSE: entity.get(CONF_PAUSE),
-                CONF_REPEAT: entity.get(CONF_REPEAT),
-            }
-            actuators.append(act)
-            _LOGGER.debug("Set up switch %s", act)
-
-        sensors = []
-        for entity in self.options.get(CONF_SENSORS) or []:
-            zone = entity[CONF_ZONE]
-
-            sensor = {
-                CONF_ZONE: zone,
-                CONF_NAME: entity.get(
-                    CONF_NAME, f"Konnected {self.device_id[6:]} Sensor {zone}"
-                ),
-                CONF_TYPE: entity[CONF_TYPE],
-                CONF_POLL_INTERVAL: entity.get(CONF_POLL_INTERVAL),
-            }
-            sensors.append(sensor)
-            _LOGGER.debug(
-                "Set up %s sensor %s (initial state: %s)",
-                sensor.get(CONF_TYPE),
-                sensor.get(CONF_NAME),
-                sensor.get(ATTR_STATE),
-            )
-
-        device_data = {
-            CONF_BINARY_SENSORS: binary_sensors,
-            CONF_SENSORS: sensors,
-            CONF_SWITCHES: actuators,
-            CONF_BLINK: self.options.get(CONF_BLINK),
-            CONF_DISCOVERY: self.options.get(CONF_DISCOVERY),
-            CONF_HOST: self.host,
-            CONF_PORT: self.port,
-            "panel": self,
-        }
-
-        if CONF_DEVICES not in self.hass.data[DOMAIN]:
-            self.hass.data[DOMAIN][CONF_DEVICES] = {}
-
-        _LOGGER.debug(
-            "Storing data in hass.data[%s][%s][%s]: %s",
-            DOMAIN,
-            CONF_DEVICES,
-            self.device_id,
-            device_data,
-        )
-        self.hass.data[DOMAIN][CONF_DEVICES][self.device_id] = device_data
-
-    @callback
-    def async_binary_sensor_configuration(self):
-        """Return the configuration map for syncing binary sensors."""
-        return [
-            self.format_zone(p) for p in self.stored_configuration[CONF_BINARY_SENSORS]
-        ]
-
-    @callback
-    def async_actuator_configuration(self):
-        """Return the configuration map for syncing actuators."""
-        return [
-            self.format_zone(
-                data[CONF_ZONE],
-                {"trigger": (0 if data.get(CONF_ACTIVATION) in [0, STATE_LOW] else 1)},
-            )
-            for data in self.stored_configuration[CONF_SWITCHES]
-        ]
-
-    @callback
-    def async_dht_sensor_configuration(self):
-        """Return the configuration map for syncing DHT sensors."""
-        return [
-            self.format_zone(
-                sensor[CONF_ZONE], {CONF_POLL_INTERVAL: sensor[CONF_POLL_INTERVAL]}
-            )
-            for sensor in self.stored_configuration[CONF_SENSORS]
-            if sensor[CONF_TYPE] == "dht"
-        ]
-
-    @callback
-    def async_ds18b20_sensor_configuration(self):
-        """Return the configuration map for syncing DS18B20 sensors."""
-        return [
-            self.format_zone(
-                sensor[CONF_ZONE], {CONF_POLL_INTERVAL: sensor[CONF_POLL_INTERVAL]}
-            )
-            for sensor in self.stored_configuration[CONF_SENSORS]
-            if sensor[CONF_TYPE] == "ds18b20"
-        ]
-
-    async def async_update_initial_states(self):
-        """Update the initial state of each sensor from status poll."""
-        for sensor_data in self.status.get("sensors"):
-            sensor_config = self.stored_configuration[CONF_BINARY_SENSORS].get(
-                sensor_data.get(CONF_ZONE, sensor_data.get(CONF_PIN)), {}
-            )
-            entity_id = sensor_config.get(ATTR_ENTITY_ID)
-
-            state = bool(sensor_data.get(ATTR_STATE))
-            if sensor_config.get(CONF_INVERSE):
-                state = not state
-
-            async_dispatcher_send(self.hass, f"konnected.{entity_id}.update", state)
-
-    @callback
-    def async_desired_settings_payload(self):
-        """Return a dict representing the desired device configuration."""
-        # keeping self.hass.data check for backwards compatibility
-        # newly configured integrations store this in the config entry
-        desired_api_host = self.options.get(CONF_API_HOST) or (
-            self.hass.data[DOMAIN].get(CONF_API_HOST) or get_url(self.hass)
-        )
-        desired_api_endpoint = desired_api_host + ENDPOINT_ROOT
-
-        return {
-            "sensors": self.async_binary_sensor_configuration(),
-            "actuators": self.async_actuator_configuration(),
-            "dht_sensors": self.async_dht_sensor_configuration(),
-            "ds18b20_sensors": self.async_ds18b20_sensor_configuration(),
-            "auth_token": self.config.get(CONF_ACCESS_TOKEN),
-            "endpoint": desired_api_endpoint,
-            "blink": self.options.get(CONF_BLINK, True),
-            "discovery": self.options.get(CONF_DISCOVERY, True),
-        }
-
-    @callback
-    def async_current_settings_payload(self):
-        """Return a dict of configuration currently stored on the device."""
-        settings = self.status["settings"] or {}
-
-        return {
-            "sensors": [
-                {self.api_version: s[self.api_version]}
-                for s in self.status.get("sensors")
-            ],
-            "actuators": self.status.get("actuators"),
-            "dht_sensors": self.status.get(CONF_DHT_SENSORS),
-            "ds18b20_sensors": self.status.get(CONF_DS18B20_SENSORS),
-            "auth_token": settings.get("token"),
-            "endpoint": settings.get("endpoint"),
-            "blink": settings.get(CONF_BLINK),
-            "discovery": settings.get(CONF_DISCOVERY),
-        }
-
-    async def async_sync_device_config(self):
-        """Sync the new zone configuration to the Konnected device if needed."""
-        _LOGGER.debug(
-            "Device %s settings payload: %s",
-            self.device_id,
-            self.async_desired_settings_payload(),
-        )
-        if (
-            self.async_desired_settings_payload()
-            != self.async_current_settings_payload()
-        ):
-            _LOGGER.debug("Pushing settings to device %s", self.device_id)
-            await self.client.put_settings(**self.async_desired_settings_payload())
-
-
-async def get_status(hass, host, port):
-    """Get the status of a Konnected Panel."""
-    client = konnected.Client(
-        host, str(port), aiohttp_client.async_get_clientsession(hass)
-    )
-    try:
-        return await client.get_status()
-
-    except client.ClientError as err:
-        _LOGGER.error("Exception trying to get panel status: %s", err)
-        raise CannotConnect from err

homeassistant/components/konnected/sensor.py

@@ -1,141 +0,0 @@
-"""Support for DHT and DS18B20 sensors attached to a Konnected device."""
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-)
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_DEVICES,
-    CONF_NAME,
-    CONF_SENSORS,
-    CONF_TYPE,
-    CONF_ZONE,
-    PERCENTAGE,
-    UnitOfTemperature,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import DOMAIN, SIGNAL_DS18B20_NEW
-
-SENSOR_TYPES: dict[str, SensorEntityDescription] = {
-    "temperature": SensorEntityDescription(
-        key="temperature",
-        name="Temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        device_class=SensorDeviceClass.TEMPERATURE,
-    ),
-    "humidity": SensorEntityDescription(
-        key="humidity",
-        name="Humidity",
-        native_unit_of_measurement=PERCENTAGE,
-        device_class=SensorDeviceClass.HUMIDITY,
-    ),
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up sensors attached to a Konnected device from a config entry."""
-    # Uses legacy hass.data[DOMAIN] pattern
-    # pylint: disable-next=home-assistant-use-runtime-data
-    data = hass.data[DOMAIN]
-    device_id = config_entry.data["id"]
-
-    # Initialize all DHT sensors.
-    dht_sensors = [
-        sensor
-        for sensor in data[CONF_DEVICES][device_id][CONF_SENSORS]
-        if sensor[CONF_TYPE] == "dht"
-    ]
-    entities = [
-        KonnectedSensor(device_id, data=sensor_config, description=description)
-        for sensor_config in dht_sensors
-        for description in SENSOR_TYPES.values()
-    ]
-
-    async_add_entities(entities)
-
-    @callback
-    def async_add_ds18b20(attrs):
-        """Add new KonnectedSensor representing a ds18b20 sensor."""
-        sensor_config = next(
-            (
-                s
-                for s in data[CONF_DEVICES][device_id][CONF_SENSORS]
-                if s[CONF_TYPE] == "ds18b20" and s[CONF_ZONE] == attrs.get(CONF_ZONE)
-            ),
-            None,
-        )
-
-        async_add_entities(
-            [
-                KonnectedSensor(
-                    device_id,
-                    sensor_config,
-                    SENSOR_TYPES["temperature"],
-                    addr=attrs.get("addr"),
-                    initial_state=attrs.get("temp"),
-                )
-            ],
-            True,
-        )
-
-    # DS18B20 sensors entities are initialized when they report for the first
-    # time. Set up a listener for that signal from the Konnected component.
-    async_dispatcher_connect(hass, SIGNAL_DS18B20_NEW, async_add_ds18b20)
-
-
-class KonnectedSensor(SensorEntity):
-    """Represents a Konnected DHT Sensor."""
-
-    def __init__(
-        self,
-        device_id,
-        data,
-        description: SensorEntityDescription,
-        addr=None,
-        initial_state=None,
-    ) -> None:
-        """Initialize the entity for a single sensor_type."""
-        self.entity_description = description
-        self._addr = addr
-        self._data = data
-        self._zone_num = self._data.get(CONF_ZONE)
-        self._attr_unique_id = addr or f"{device_id}-{self._zone_num}-{description.key}"
-
-        # set initial state if known at initialization
-        self._attr_native_value = initial_state
-        if initial_state:
-            self._attr_native_value = round(float(initial_state), 1)
-
-        # set entity name if given
-        if name := self._data.get(CONF_NAME):
-            name += f" {description.name}"
-        self._attr_name = name
-
-        self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, device_id)})
-
-    async def async_added_to_hass(self) -> None:
-        """Store entity_id and register state change callback."""
-        entity_id_key = self._addr or self.entity_description.key
-        self._data[entity_id_key] = self.entity_id
-        async_dispatcher_connect(
-            self.hass, f"konnected.{self.entity_id}.update", self.async_set_state
-        )
-
-    @callback
-    def async_set_state(self, state):
-        """Update the sensor's state."""
-        if self.entity_description.key == "humidity":
-            self._attr_native_value = int(float(state))
-        else:
-            self._attr_native_value = round(float(state), 1)
-        self.async_write_ha_state()

homeassistant/components/konnected/strings.json

@@ -1,115 +1,8 @@
 {
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "not_konn_panel": "Not a recognized Konnected.io device",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
-    },
-    "step": {
-      "confirm": {
-        "description": "Model: {model}\nID: {id}\nHost: {host}\nPort: {port}\n\nYou can configure the IO and panel behavior in the Konnected alarm panel settings.",
-        "title": "Konnected device ready"
-      },
-      "import_confirm": {
-        "description": "A Konnected alarm panel with ID {id} has been discovered in configuration.yaml. This flow will allow you to import it into a config entry.",
-        "title": "Import Konnected device"
-      },
-      "user": {
-        "data": {
-          "host": "[%key:common::config_flow::data::ip%]",
-          "port": "[%key:common::config_flow::data::port%]"
-        },
-        "description": "Please enter the host information for your Konnected panel."
-      }
-    }
-  },
   "issues": {
-    "deprecated_firmware": {
-      "description": "Konnected's integration is deprecated and Konnected strongly recommends migrating to their ESPHome based firmware and integration by following the guide at {kb_page_url}. After this migration, make sure you don't have any Konnected YAML configuration left in your configuration.yaml file and remove this integration from Home Assistant.",
-      "title": "Konnected firmware is deprecated"
-    }
-  },
-  "options": {
-    "abort": {
-      "not_konn_panel": "[%key:component::konnected::config::abort::not_konn_panel%]"
-    },
-    "error": {
-      "bad_host": "Invalid custom API host URL"
-    },
-    "step": {
-      "options_binary": {
-        "data": {
-          "inverse": "Invert the open/close state",
-          "name": "[%key:common::config_flow::data::name%]",
-          "type": "Binary sensor type"
-        },
-        "description": "{zone} options",
-        "title": "Configure binary sensor"
-      },
-      "options_digital": {
-        "data": {
-          "name": "[%key:common::config_flow::data::name%]",
-          "poll_interval": "Poll interval (minutes)",
-          "type": "Sensor type"
-        },
-        "description": "[%key:component::konnected::options::step::options_binary::description%]",
-        "title": "Configure digital sensor"
-      },
-      "options_io": {
-        "data": {
-          "1": "Zone 1",
-          "2": "Zone 2",
-          "3": "Zone 3",
-          "4": "Zone 4",
-          "5": "Zone 5",
-          "6": "Zone 6",
-          "7": "Zone 7",
-          "out": "OUT"
-        },
-        "description": "Discovered a {model} at {host}. Select the base configuration of each I/O below - depending on the I/O it may allow for binary sensors (open/close contacts), digital sensors (dht and ds18b20), or switchable outputs. You'll be able to configure detailed options in the next steps.",
-        "title": "Configure I/O"
-      },
-      "options_io_ext": {
-        "data": {
-          "8": "Zone 8",
-          "9": "Zone 9",
-          "10": "Zone 10",
-          "11": "Zone 11",
-          "12": "Zone 12",
-          "alarm1": "ALARM1",
-          "alarm2_out2": "OUT2/ALARM2",
-          "out1": "OUT1"
-        },
-        "description": "Select the configuration of the remaining I/O below. You'll be able to configure detailed options in the next steps.",
-        "title": "Configure extended I/O"
-      },
-      "options_misc": {
-        "data": {
-          "api_host": "Custom API host URL",
-          "blink": "Blink panel LED on when sending state change",
-          "discovery": "Respond to discovery requests on your network",
-          "override_api_host": "Override default Home Assistant API host URL"
-        },
-        "description": "Please select the desired behavior for your panel",
-        "title": "Configure misc"
-      },
-      "options_switch": {
-        "data": {
-          "activation": "Output when on",
-          "momentary": "Pulse duration (ms)",
-          "more_states": "Configure additional states for this zone",
-          "name": "[%key:common::config_flow::data::name%]",
-          "pause": "Pause between pulses (ms)",
-          "repeat": "Times to repeat (-1=infinite)"
-        },
-        "description": "{zone} options: state {state}",
-        "title": "Configure switchable output"
-      }
+    "integration_removed": {
+      "description": "The Konnected.io (Legacy) integration relied on Konnected's deprecated firmware and has been removed from Home Assistant. Konnected recommends migrating to their ESPHome based firmware and the corresponding Home Assistant integration by following the [migration guide]({kb_page_url}).\n\nTo resolve this issue, migrate your Konnected device(s) to the ESPHome based firmware, then remove any `konnected:` YAML configuration from your `configuration.yaml` file, and remove the (now defunct) integration entries from your Home Assistant setup. [Click here to see your existing Konnected.io (Legacy) integration entries]({entries}).",
+      "title": "The Konnected.io (Legacy) integration has been removed"
     }
   }
 }

homeassistant/components/konnected/switch.py

@@ -1,135 +0,0 @@
-"""Support for wired switches attached to a Konnected device."""
-# pylint: disable=home-assistant-use-runtime-data  # Uses legacy hass.data[DOMAIN] pattern
-
-import logging
-from typing import Any
-
-from homeassistant.components.switch import SwitchEntity
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    ATTR_STATE,
-    CONF_DEVICES,
-    CONF_NAME,
-    CONF_REPEAT,
-    CONF_SWITCHES,
-    CONF_ZONE,
-)
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import (
-    CONF_ACTIVATION,
-    CONF_MOMENTARY,
-    CONF_PAUSE,
-    DOMAIN,
-    STATE_HIGH,
-    STATE_LOW,
-)
-
-_LOGGER = logging.getLogger(__name__)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up switches attached to a Konnected device from a config entry."""
-    data = hass.data[DOMAIN]
-    device_id = config_entry.data["id"]
-    switches = [
-        KonnectedSwitch(device_id, zone_data.get(CONF_ZONE), zone_data)
-        for zone_data in data[CONF_DEVICES][device_id][CONF_SWITCHES]
-    ]
-    async_add_entities(switches)
-
-
-class KonnectedSwitch(SwitchEntity):
-    """Representation of a Konnected switch."""
-
-    def __init__(self, device_id, zone_num, data):
-        """Initialize the Konnected switch."""
-        self._data = data
-        self._device_id = device_id
-        self._zone_num = zone_num
-        self._activation = self._data.get(CONF_ACTIVATION, STATE_HIGH)
-        self._momentary = self._data.get(CONF_MOMENTARY)
-        self._pause = self._data.get(CONF_PAUSE)
-        self._repeat = self._data.get(CONF_REPEAT)
-        self._attr_is_on = self._boolean_state(self._data.get(ATTR_STATE))
-        self._attr_name = self._data.get(CONF_NAME)
-        self._attr_unique_id = (
-            f"{device_id}-{self._zone_num}-{self._momentary}-"
-            f"{self._pause}-{self._repeat}"
-        )
-        self._attr_device_info = DeviceInfo(identifiers={(DOMAIN, device_id)})
-
-    @property
-    def panel(self):
-        """Return the Konnected HTTP client."""
-        device_data = self.hass.data[DOMAIN][CONF_DEVICES][self._device_id]
-        return device_data.get("panel")
-
-    @property
-    def available(self) -> bool:
-        """Return whether the panel is available."""
-        return self.panel.available
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Send a command to turn on the switch."""
-        resp = await self.panel.update_switch(
-            self._zone_num,
-            int(self._activation == STATE_HIGH),
-            self._momentary,
-            self._repeat,
-            self._pause,
-        )
-
-        if resp.get(ATTR_STATE) is not None:
-            self._set_state(True)
-
-            if self._momentary and resp.get(ATTR_STATE) != -1:
-                # Immediately set the state back off for momentary switches
-                self._set_state(False)
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Send a command to turn off the switch."""
-        resp = await self.panel.update_switch(
-            self._zone_num, int(self._activation == STATE_LOW)
-        )
-
-        if resp.get(ATTR_STATE) is not None:
-            self._set_state(self._boolean_state(resp.get(ATTR_STATE)))
-
-    def _boolean_state(self, int_state: int | None) -> bool | None:
-        if int_state == 0:
-            return self._activation == STATE_LOW
-        if int_state == 1:
-            return self._activation == STATE_HIGH
-        return None
-
-    def _set_state(self, state):
-        self._attr_is_on = state
-        self.async_write_ha_state()
-        _LOGGER.debug(
-            "Setting status of %s actuator zone %s to %s",
-            self._device_id,
-            self.name,
-            state,
-        )
-
-    @callback
-    def async_set_state(self, state):
-        """Update the switch state."""
-        self._set_state(state)
-
-    async def async_added_to_hass(self) -> None:
-        """Store entity_id and register state change callback."""
-        self._data["entity_id"] = self.entity_id
-        self.async_on_remove(
-            async_dispatcher_connect(
-                self.hass, f"konnected.{self.entity_id}.update", self.async_set_state
-            )
-        )

homeassistant/generated/config_flows.py

@@ -384,7 +384,6 @@ FLOWS = {
         "knocki",
         "knx",
         "kodi",
-        "konnected",
         "kostal_plenticore",
         "kraken",
         "kulersky",

homeassistant/generated/integrations.json

@@ -3574,12 +3574,6 @@
     "konnected": {
       "name": "Konnected",
       "integrations": {
-        "konnected": {
-          "integration_type": "hub",
-          "config_flow": true,
-          "iot_class": "local_push",
-          "name": "Konnected.io (Legacy)"
-        },
         "konnected_esphome": {
           "integration_type": "virtual",
           "config_flow": false,

homeassistant/generated/ssdp.py

@@ -201,11 +201,6 @@ SSDP = {
             "manufacturer": "ZyXEL Communications Corp.",
         },
     ],
-    "konnected": [
-        {
-            "manufacturer": "konnected.io",
-        },
-    ],
     "lametric": [
         {
             "deviceType": "urn:schemas-upnp-org:device:LaMetric:1",

requirements_all.txt

@@ -1422,9 +1422,6 @@ knocki==0.4.2
 # homeassistant.components.knx
 knx-frontend==2026.4.30.60856
 
-# homeassistant.components.konnected
-konnected==1.2.0
-
 # homeassistant.components.kraken
 krakenex==2.2.2
 

tests/components/konnected/test_init.py

@@ -1,950 +1,61 @@
-"""Test Konnected setup process."""
+"""Tests for the Konnected.io component."""
 
-from http import HTTPStatus
-from unittest.mock import patch
-
-import pytest
-
-from homeassistant.components import konnected
-from homeassistant.components.konnected import config_flow
+from homeassistant.components.konnected import DOMAIN
+from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
-from homeassistant.core_config import async_process_ha_core_config
+from homeassistant.helpers import issue_registry as ir
 from homeassistant.setup import async_setup_component
 
 from tests.common import MockConfigEntry
-from tests.typing import ClientSessionGenerator
 
 
-@pytest.fixture(name="mock_panel")
-async def mock_panel_fixture():
-    """Mock a Konnected Panel bridge."""
-    with patch("konnected.Client", autospec=True) as konn_client:
-
-        def mock_constructor(host, port, websession):
-            """Fake the panel constructor."""
-            konn_client.host = host
-            konn_client.port = port
-            return konn_client
-
-        konn_client.side_effect = mock_constructor
-        konn_client.ClientError = config_flow.CannotConnect
-        konn_client.get_status.return_value = {
-            "hwVersion": "2.3.0",
-            "swVersion": "2.3.1",
-            "heap": 10000,
-            "uptime": 12222,
-            "ip": "192.168.1.90",
-            "port": 9123,
-            "sensors": [],
-            "actuators": [],
-            "dht_sensors": [],
-            "ds18b20_sensors": [],
-            "mac": "11:22:33:44:55:66",
-            "settings": {},
-        }
-        yield konn_client
-
-
-async def test_config_schema(hass: HomeAssistant) -> None:
-    """Test that config schema is imported properly."""
-    config = {
-        konnected.DOMAIN: {
-            konnected.CONF_API_HOST: "http://1.1.1.1:8888",
-            konnected.CONF_ACCESS_TOKEN: "abcdefgh",
-            konnected.CONF_DEVICES: [{konnected.CONF_ID: "aabbccddeeff"}],
-        }
-    }
-    assert konnected.CONFIG_SCHEMA(config) == {
-        "konnected": {
-            "access_token": "abcdefgh",
-            "api_host": "http://1.1.1.1:8888",
-            "devices": [
-                {
-                    "default_options": {
-                        "blink": True,
-                        "api_host": "http://1.1.1.1:8888",
-                        "discovery": True,
-                        "io": {
-                            "1": "Disabled",
-                            "10": "Disabled",
-                            "11": "Disabled",
-                            "12": "Disabled",
-                            "2": "Disabled",
-                            "3": "Disabled",
-                            "4": "Disabled",
-                            "5": "Disabled",
-                            "6": "Disabled",
-                            "7": "Disabled",
-                            "8": "Disabled",
-                            "9": "Disabled",
-                            "alarm1": "Disabled",
-                            "alarm2_out2": "Disabled",
-                            "out": "Disabled",
-                            "out1": "Disabled",
-                        },
-                    },
-                    "id": "aabbccddeeff",
-                }
-            ],
-        }
-    }
-
-    # check with host info
-    config = {
-        konnected.DOMAIN: {
-            konnected.CONF_ACCESS_TOKEN: "abcdefgh",
-            konnected.CONF_DEVICES: [
-                {konnected.CONF_ID: "aabbccddeeff", "host": "192.168.1.1", "port": 1234}
-            ],
-        }
-    }
-    assert konnected.CONFIG_SCHEMA(config) == {
-        "konnected": {
-            "access_token": "abcdefgh",
-            "devices": [
-                {
-                    "default_options": {
-                        "blink": True,
-                        "api_host": "",
-                        "discovery": True,
-                        "io": {
-                            "1": "Disabled",
-                            "10": "Disabled",
-                            "11": "Disabled",
-                            "12": "Disabled",
-                            "2": "Disabled",
-                            "3": "Disabled",
-                            "4": "Disabled",
-                            "5": "Disabled",
-                            "6": "Disabled",
-                            "7": "Disabled",
-                            "8": "Disabled",
-                            "9": "Disabled",
-                            "alarm1": "Disabled",
-                            "alarm2_out2": "Disabled",
-                            "out": "Disabled",
-                            "out1": "Disabled",
-                        },
-                    },
-                    "id": "aabbccddeeff",
-                    "host": "192.168.1.1",
-                    "port": 1234,
-                }
-            ],
-        }
-    }
-
-    # check pin to zone and multiple output
-    config = {
-        konnected.DOMAIN: {
-            konnected.CONF_ACCESS_TOKEN: "abcdefgh",
-            konnected.CONF_DEVICES: [
-                {
-                    konnected.CONF_ID: "aabbccddeeff",
-                    "binary_sensors": [
-                        {"pin": 2, "type": "door"},
-                        {"zone": 1, "type": "door"},
-                    ],
-                    "switches": [
-                        {
-                            "zone": 3,
-                            "name": "Beep Beep",
-                            "momentary": 65,
-                            "pause": 55,
-                            "repeat": 4,
-                        },
-                        {
-                            "zone": 3,
-                            "name": "Warning",
-                            "momentary": 100,
-                            "pause": 100,
-                            "repeat": -1,
-                        },
-                    ],
-                }
-            ],
-        }
-    }
-    assert konnected.CONFIG_SCHEMA(config) == {
-        "konnected": {
-            "access_token": "abcdefgh",
-            "devices": [
-                {
-                    "default_options": {
-                        "blink": True,
-                        "api_host": "",
-                        "discovery": True,
-                        "io": {
-                            "1": "Binary Sensor",
-                            "10": "Disabled",
-                            "11": "Disabled",
-                            "12": "Disabled",
-                            "2": "Binary Sensor",
-                            "3": "Switchable Output",
-                            "4": "Disabled",
-                            "5": "Disabled",
-                            "6": "Disabled",
-                            "7": "Disabled",
-                            "8": "Disabled",
-                            "9": "Disabled",
-                            "alarm1": "Disabled",
-                            "alarm2_out2": "Disabled",
-                            "out": "Disabled",
-                            "out1": "Disabled",
-                        },
-                        "binary_sensors": [
-                            {"inverse": False, "type": "door", "zone": "2"},
-                            {"inverse": False, "type": "door", "zone": "1"},
-                        ],
-                        "switches": [
-                            {
-                                "zone": "3",
-                                "activation": "high",
-                                "name": "Beep Beep",
-                                "momentary": 65,
-                                "pause": 55,
-                                "repeat": 4,
-                            },
-                            {
-                                "zone": "3",
-                                "activation": "high",
-                                "name": "Warning",
-                                "momentary": 100,
-                                "pause": 100,
-                                "repeat": -1,
-                            },
-                        ],
-                    },
-                    "id": "aabbccddeeff",
-                }
-            ],
-        }
-    }
-
-
-async def test_setup_with_no_config(hass: HomeAssistant) -> None:
-    """Test that we do not discover anything or try to set up a Konnected panel."""
-    assert await async_setup_component(hass, konnected.DOMAIN, {})
-
-    # No flows started
-    assert len(hass.config_entries.flow.async_progress()) == 0
-
-    # Nothing saved from configuration.yaml
-    assert hass.data[konnected.DOMAIN][konnected.CONF_ACCESS_TOKEN] is None
-    assert hass.data[konnected.DOMAIN][konnected.CONF_API_HOST] is None
-    assert konnected.YAML_CONFIGS not in hass.data[konnected.DOMAIN]
-
-
-async def test_setup_defined_hosts_known_auth(hass: HomeAssistant, mock_panel) -> None:
-    """Test we don't initiate a config entry if configured panel is known."""
-    MockConfigEntry(
-        domain="konnected",
-        unique_id="112233445566",
-        data={"host": "0.0.0.0", "id": "112233445566"},
-    ).add_to_hass(hass)
-    MockConfigEntry(
-        domain="konnected",
-        unique_id="aabbccddeeff",
-        data={"host": "1.2.3.4", "id": "aabbccddeeff"},
-    ).add_to_hass(hass)
-
-    assert (
-        await async_setup_component(
-            hass,
-            konnected.DOMAIN,
-            {
-                konnected.DOMAIN: {
-                    konnected.CONF_ACCESS_TOKEN: "abcdefgh",
-                    konnected.CONF_DEVICES: [
-                        {
-                            config_flow.CONF_ID: "aabbccddeeff",
-                            config_flow.CONF_HOST: "0.0.0.0",
-                            config_flow.CONF_PORT: 1234,
-                        }
-                    ],
-                }
-            },
-        )
-        is True
-    )
-
-    assert hass.data[konnected.DOMAIN][konnected.CONF_ACCESS_TOKEN] == "abcdefgh"
-    assert konnected.YAML_CONFIGS not in hass.data[konnected.DOMAIN]
-
-    # Flow aborted
-    assert len(hass.config_entries.flow.async_progress()) == 0
-
-
-async def test_setup_defined_hosts_no_known_auth(hass: HomeAssistant) -> None:
-    """Test we initiate config entry if config panel is not known."""
-    assert (
-        await async_setup_component(
-            hass,
-            konnected.DOMAIN,
-            {
-                konnected.DOMAIN: {
-                    konnected.CONF_ACCESS_TOKEN: "abcdefgh",
-                    konnected.CONF_DEVICES: [{konnected.CONF_ID: "aabbccddeeff"}],
-                }
-            },
-        )
-        is True
-    )
-
-    # Flow started for discovered bridge
-    assert len(hass.config_entries.flow.async_progress()) == 1
-
-
-async def test_setup_multiple(hass: HomeAssistant) -> None:
-    """Test we initiate config entry for multiple panels."""
-    assert (
-        await async_setup_component(
-            hass,
-            konnected.DOMAIN,
-            {
-                konnected.DOMAIN: {
-                    konnected.CONF_ACCESS_TOKEN: "arandomstringvalue",
-                    konnected.CONF_API_HOST: "http://192.168.86.32:8123",
-                    konnected.CONF_DEVICES: [
-                        {
-                            konnected.CONF_ID: "aabbccddeeff",
-                            "binary_sensors": [
-                                {"zone": 4, "type": "motion", "name": "Hallway Motion"},
-                                {
-                                    "zone": 5,
-                                    "type": "window",
-                                    "name": "Master Bedroom Window",
-                                },
-                                {
-                                    "zone": 6,
-                                    "type": "window",
-                                    "name": "Downstairs Windows",
-                                },
-                            ],
-                            "switches": [{"zone": "out", "name": "siren"}],
-                        },
-                        {
-                            konnected.CONF_ID: "445566778899",
-                            "binary_sensors": [
-                                {"zone": 1, "type": "motion", "name": "Front"},
-                                {"zone": 2, "type": "window", "name": "Back"},
-                            ],
-                            "switches": [
-                                {
-                                    "zone": "out",
-                                    "name": "Buzzer",
-                                    "momentary": 65,
-                                    "pause": 55,
-                                    "repeat": 4,
-                                }
-                            ],
-                        },
-                    ],
-                }
-            },
-        )
-        is True
-    )
-
-    # Flow started for discovered bridge
-    assert len(hass.config_entries.flow.async_progress()) == 2
-
-    # Globals saved
-    assert (
-        hass.data[konnected.DOMAIN][konnected.CONF_ACCESS_TOKEN] == "arandomstringvalue"
-    )
-    assert (
-        hass.data[konnected.DOMAIN][konnected.CONF_API_HOST]
-        == "http://192.168.86.32:8123"
-    )
-
-
-async def test_config_passed_to_config_entry(hass: HomeAssistant) -> None:
-    """Test that configured options for a host are loaded via config entry."""
-    entry = MockConfigEntry(
-        domain=konnected.DOMAIN,
-        data={config_flow.CONF_ID: "aabbccddeeff", config_flow.CONF_HOST: "0.0.0.0"},
-    )
-    entry.add_to_hass(hass)
-    with patch.object(konnected, "AlarmPanel", autospec=True) as mock_int:
-        assert (
-            await async_setup_component(
-                hass,
-                konnected.DOMAIN,
-                {
-                    konnected.DOMAIN: {
-                        konnected.CONF_ACCESS_TOKEN: "abcdefgh",
-                        konnected.CONF_DEVICES: [{konnected.CONF_ID: "aabbccddeeff"}],
-                    }
-                },
-            )
-            is True
-        )
-
-    assert len(mock_int.mock_calls) == 3
-    p_hass, p_entry = mock_int.mock_calls[0][1]
-
-    assert p_hass is hass
-    assert p_entry is entry
-
-
-async def test_unload_entry(hass: HomeAssistant, mock_panel) -> None:
-    """Test being able to unload an entry."""
-    await async_process_ha_core_config(
-        hass,
-        {"internal_url": "http://example.local:8123"},
-    )
-    entry = MockConfigEntry(
-        domain=konnected.DOMAIN, data={konnected.CONF_ID: "aabbccddeeff"}
-    )
-    entry.add_to_hass(hass)
-
-    assert await async_setup_component(hass, konnected.DOMAIN, {}) is True
-    assert hass.data[konnected.DOMAIN]["devices"].get("aabbccddeeff") is not None
-    assert await konnected.async_unload_entry(hass, entry)
-    assert hass.data[konnected.DOMAIN]["devices"] == {}
-
-
-async def test_api(
-    hass: HomeAssistant, hass_client_no_auth: ClientSessionGenerator, mock_panel
+async def test_konnected_repair_issue(
+    hass: HomeAssistant, issue_registry: ir.IssueRegistry
 ) -> None:
-    """Test callback view."""
-    await async_setup_component(hass, "http", {"http": {}})
-
-    device_config = config_flow.CONFIG_ENTRY_SCHEMA(
-        {
-            "host": "1.2.3.4",
-            "port": 1234,
-            "id": "112233445566",
-            "model": "Konnected Pro",
-            "access_token": "abcdefgh",
-            "api_host": "http://192.168.86.32:8123",
-            "default_options": config_flow.OPTIONS_SCHEMA({config_flow.CONF_IO: {}}),
-        }
+    """Test the Konnected.io 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
 
-    device_options = config_flow.OPTIONS_SCHEMA(
-        {
-            "api_host": "http://192.168.86.32:8123",
-            "io": {
-                "1": "Binary Sensor",
-                "2": "Binary Sensor",
-                "3": "Binary Sensor",
-                "4": "Digital Sensor",
-                "5": "Digital Sensor",
-                "6": "Switchable Output",
-                "out": "Switchable Output",
-            },
-            "binary_sensors": [
-                {"zone": "1", "type": "door"},
-                {"zone": "2", "type": "window", "name": "winder", "inverse": True},
-                {"zone": "3", "type": "door"},
-            ],
-            "sensors": [
-                {"zone": "4", "type": "dht"},
-                {"zone": "5", "type": "ds18b20", "name": "temper"},
-            ],
-            "switches": [
-                {
-                    "zone": "out",
-                    "name": "switcher",
-                    "activation": "low",
-                    "momentary": 50,
-                    "pause": 100,
-                    "repeat": 4,
-                },
-                {"zone": "6"},
-            ],
-        }
+    # 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()
 
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Alarm Panel",
-        data=device_config,
-        options=device_options,
-    )
-    entry.add_to_hass(hass)
+    assert config_entry_2.state is ConfigEntryState.LOADED
+    assert issue_registry.async_get_issue(DOMAIN, DOMAIN)
 
-    assert (
-        await async_setup_component(
-            hass,
-            konnected.DOMAIN,
-            {konnected.DOMAIN: {konnected.CONF_ACCESS_TOKEN: "globaltoken"}},
-        )
-        is True
-    )
+    # Remove the first one
+    await hass.config_entries.async_remove(config_entry_1.entry_id)
+    await hass.async_block_till_done()
 
-    client = await hass_client_no_auth()
+    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)
 
-    # Test the get endpoint for switch status polling
-    resp = await client.get("/api/konnected")
-    assert resp.status == HTTPStatus.NOT_FOUND  # no device provided
+    # Remove the second one
+    await hass.config_entries.async_remove(config_entry_2.entry_id)
+    await hass.async_block_till_done()
 
-    resp = await client.get("/api/konnected/223344556677")
-    assert resp.status == HTTPStatus.NOT_FOUND  # unknown device provided
-
-    resp = await client.get("/api/konnected/device/112233445566")
-    assert resp.status == HTTPStatus.NOT_FOUND  # no zone provided
-    result = await resp.json()
-    assert result == {"message": "Switch on zone or pin unknown not configured"}
-
-    resp = await client.get("/api/konnected/device/112233445566?zone=8")
-    assert resp.status == HTTPStatus.NOT_FOUND  # invalid zone
-    result = await resp.json()
-    assert result == {"message": "Switch on zone or pin 8 not configured"}
-
-    resp = await client.get("/api/konnected/device/112233445566?pin=12")
-    assert resp.status == HTTPStatus.NOT_FOUND  # invalid pin
-    result = await resp.json()
-    assert result == {"message": "Switch on zone or pin 12 not configured"}
-
-    resp = await client.get("/api/konnected/device/112233445566?zone=out")
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"state": 1, "zone": "out"}
-
-    resp = await client.get("/api/konnected/device/112233445566?pin=8")
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"state": 1, "pin": "8"}
-
-    # Test the post endpoint for sensor updates
-    resp = await client.post("/api/konnected/device", json={"zone": "1", "state": 1})
-    assert resp.status == HTTPStatus.NOT_FOUND
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566", json={"zone": "1", "state": 1}
-    )
-    assert resp.status == HTTPStatus.UNAUTHORIZED
-    result = await resp.json()
-    assert result == {"message": "unauthorized"}
-
-    resp = await client.post(
-        "/api/konnected/device/223344556677",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "1", "state": 1},
-    )
-    assert resp.status == HTTPStatus.BAD_REQUEST
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "15", "state": 1},
-    )
-    assert resp.status == HTTPStatus.BAD_REQUEST
-    result = await resp.json()
-    assert result == {"message": "unregistered sensor/actuator"}
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "1", "state": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer globaltoken"},
-        json={"zone": "1", "state": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "4", "temp": 22, "humi": 20},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-
-    # Test the put endpoint for sensor updates
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "1", "state": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
+    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
 
 
-async def test_state_updates_zone(
-    hass: HomeAssistant, hass_client_no_auth: ClientSessionGenerator, mock_panel
+async def test_konnected_yaml_repair_issue(
+    hass: HomeAssistant, issue_registry: ir.IssueRegistry
 ) -> None:
-    """Test callback view."""
-    await async_process_ha_core_config(
-        hass,
-        {"internal_url": "http://example.local:8123"},
-    )
-
-    device_config = config_flow.CONFIG_ENTRY_SCHEMA(
-        {
-            "host": "1.2.3.4",
-            "port": 1234,
-            "id": "112233445566",
-            "model": "Konnected Pro",
-            "access_token": "abcdefgh",
-            "default_options": config_flow.OPTIONS_SCHEMA({config_flow.CONF_IO: {}}),
-        }
-    )
-
-    device_options = config_flow.OPTIONS_SCHEMA(
-        {
-            "io": {
-                "1": "Binary Sensor",
-                "2": "Binary Sensor",
-                "3": "Binary Sensor",
-                "4": "Digital Sensor",
-                "5": "Digital Sensor",
-                "6": "Switchable Output",
-                "out": "Switchable Output",
-            },
-            "binary_sensors": [
-                {"zone": "1", "type": "door"},
-                {"zone": "2", "type": "window", "name": "winder", "inverse": True},
-                {"zone": "3", "type": "door"},
-            ],
-            "sensors": [
-                {"zone": "4", "type": "dht"},
-                {"zone": "5", "type": "ds18b20", "name": "temper"},
-            ],
-            "switches": [
-                {
-                    "zone": "out",
-                    "name": "switcher",
-                    "activation": "low",
-                    "momentary": 50,
-                    "pause": 100,
-                    "repeat": 4,
-                },
-                {"zone": "6"},
-            ],
-        }
-    )
-
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Alarm Panel",
-        data=device_config,
-        options=device_options,
-    )
-    entry.add_to_hass(hass)
-
-    # Add empty data field to ensure we process it correctly
-    # (possible if entry is ignored)
-    entry = MockConfigEntry(domain="konnected", title="Konnected Alarm Panel", data={})
-    entry.add_to_hass(hass)
-
-    assert (
-        await async_setup_component(
-            hass,
-            konnected.DOMAIN,
-            {konnected.DOMAIN: {konnected.CONF_ACCESS_TOKEN: "1122334455"}},
-        )
-        is True
-    )
-
-    client = await hass_client_no_auth()
-
-    # Test updating a binary sensor
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "1", "state": 0},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
+    """Test the repair issue is created when YAML configuration is present."""
+    assert await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
     await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "binary_sensor.konnected_alarm_panel_konnected_445566_zone_1"
-        ).state
-        == "off"
-    )
 
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "1", "state": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "binary_sensor.konnected_alarm_panel_konnected_445566_zone_1"
-        ).state
-        == "on"
-    )
-
-    # Test updating sht sensor
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "4", "temp": 22, "humi": 20},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_humidity"
-        ).state
-        == "20"
-    )
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_temperature"
-        ).state
-        == "22.0"
-    )
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "4", "temp": 25, "humi": 23},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_humidity"
-        ).state
-        == "23"
-    )
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_temperature"
-        ).state
-        == "25.0"
-    )
-
-    # Test updating ds sensor
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "5", "temp": 32.0, "addr": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get("sensor.konnected_alarm_panel_temper_temperature").state
-        == "32.0"
-    )
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"zone": "5", "temp": 42, "addr": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get("sensor.konnected_alarm_panel_temper_temperature").state
-        == "42.0"
-    )
-
-
-async def test_state_updates_pin(
-    hass: HomeAssistant, hass_client_no_auth: ClientSessionGenerator, mock_panel
-) -> None:
-    """Test callback view."""
-    await async_process_ha_core_config(
-        hass,
-        {"internal_url": "http://example.local:8123"},
-    )
-
-    device_config = config_flow.CONFIG_ENTRY_SCHEMA(
-        {
-            "host": "1.2.3.4",
-            "port": 1234,
-            "id": "112233445566",
-            "model": "Konnected",
-            "access_token": "abcdefgh",
-            "default_options": config_flow.OPTIONS_SCHEMA({config_flow.CONF_IO: {}}),
-        }
-    )
-
-    device_options = config_flow.OPTIONS_SCHEMA(
-        {
-            "io": {
-                "1": "Binary Sensor",
-                "2": "Binary Sensor",
-                "3": "Binary Sensor",
-                "4": "Digital Sensor",
-                "5": "Digital Sensor",
-                "6": "Switchable Output",
-                "out": "Switchable Output",
-            },
-            "binary_sensors": [
-                {"zone": "1", "type": "door"},
-                {"zone": "2", "type": "window", "name": "winder", "inverse": True},
-                {"zone": "3", "type": "door"},
-            ],
-            "sensors": [
-                {"zone": "4", "type": "dht"},
-                {"zone": "5", "type": "ds18b20", "name": "temper"},
-            ],
-            "switches": [
-                {
-                    "zone": "out",
-                    "name": "switcher",
-                    "activation": "low",
-                    "momentary": 50,
-                    "pause": 100,
-                    "repeat": 4,
-                },
-                {"zone": "6"},
-            ],
-        }
-    )
-
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Alarm Panel",
-        data=device_config,
-        options=device_options,
-    )
-    entry.add_to_hass(hass)
-
-    # Add empty data field to ensure we process it correctly
-    # (possible if entry is ignored)
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Alarm Panel",
-        data={},
-    )
-    entry.add_to_hass(hass)
-
-    assert (
-        await async_setup_component(
-            hass,
-            konnected.DOMAIN,
-            {konnected.DOMAIN: {konnected.CONF_ACCESS_TOKEN: "1122334455"}},
-        )
-        is True
-    )
-
-    client = await hass_client_no_auth()
-
-    # Test updating a binary sensor
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"pin": "1", "state": 0},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "binary_sensor.konnected_alarm_panel_konnected_445566_zone_1"
-        ).state
-        == "off"
-    )
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"pin": "1", "state": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "binary_sensor.konnected_alarm_panel_konnected_445566_zone_1"
-        ).state
-        == "on"
-    )
-
-    # Test updating sht sensor
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"pin": "6", "temp": 22, "humi": 20},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_humidity"
-        ).state
-        == "20"
-    )
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_temperature"
-        ).state
-        == "22.0"
-    )
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"pin": "6", "temp": 25, "humi": 23},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_humidity"
-        ).state
-        == "23"
-    )
-    assert (
-        hass.states.get(
-            "sensor.konnected_alarm_panel_konnected_445566_sensor_4_temperature"
-        ).state
-        == "25.0"
-    )
-
-    # Test updating ds sensor
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"pin": "7", "temp": 32.0, "addr": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get("sensor.konnected_alarm_panel_temper_temperature").state
-        == "32.0"
-    )
-
-    resp = await client.post(
-        "/api/konnected/device/112233445566",
-        headers={"Authorization": "Bearer abcdefgh"},
-        json={"pin": "7", "temp": 42, "addr": 1},
-    )
-    assert resp.status == HTTPStatus.OK
-    result = await resp.json()
-    assert result == {"message": "ok"}
-    await hass.async_block_till_done()
-    assert (
-        hass.states.get("sensor.konnected_alarm_panel_temper_temperature").state
-        == "42.0"
-    )
+    assert issue_registry.async_get_issue(DOMAIN, DOMAIN)

tests/components/konnected/test_panel.py

@@ -1,739 +0,0 @@
-"""Test Konnected setup process."""
-
-from datetime import timedelta
-from unittest.mock import patch
-
-import pytest
-
-from homeassistant.components.konnected import config_flow, panel
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_component import async_update_entity
-from homeassistant.setup import async_setup_component
-from homeassistant.util import utcnow
-
-from tests.common import MockConfigEntry, async_fire_time_changed
-
-
-@pytest.fixture(name="mock_panel")
-async def mock_panel_fixture():
-    """Mock a Konnected Panel bridge."""
-    with patch("konnected.Client", autospec=True) as konn_client:
-
-        def mock_constructor(host, port, websession):
-            """Fake the panel constructor."""
-            konn_client.host = host
-            konn_client.port = port
-            return konn_client
-
-        konn_client.side_effect = mock_constructor
-        konn_client.ClientError = config_flow.CannotConnect
-        konn_client.get_status.return_value = {
-            "hwVersion": "2.3.0",
-            "swVersion": "2.3.1",
-            "heap": 10000,
-            "uptime": 12222,
-            "ip": "192.168.1.90",
-            "port": 9123,
-            "sensors": [],
-            "actuators": [],
-            "dht_sensors": [],
-            "ds18b20_sensors": [],
-            "mac": "11:22:33:44:55:66",
-            "model": "Konnected Pro",  # `model` field only included in pro
-            "settings": {},
-        }
-        yield konn_client
-
-
-async def test_create_and_setup(hass: HomeAssistant, mock_panel) -> None:
-    """Test that we create a Konnected Panel and save the data."""
-    device_config = config_flow.CONFIG_ENTRY_SCHEMA(
-        {
-            "host": "1.2.3.4",
-            "port": 1234,
-            "id": "112233445566",
-            "model": "Konnected Pro",
-            "access_token": "11223344556677889900",
-            "default_options": config_flow.OPTIONS_SCHEMA({config_flow.CONF_IO: {}}),
-        }
-    )
-
-    device_options = config_flow.OPTIONS_SCHEMA(
-        {
-            "io": {
-                "1": "Binary Sensor",
-                "2": "Binary Sensor",
-                "3": "Binary Sensor",
-                "4": "Digital Sensor",
-                "5": "Digital Sensor",
-                "6": "Switchable Output",
-                "out": "Switchable Output",
-            },
-            "binary_sensors": [
-                {"zone": "1", "type": "door"},
-                {"zone": "2", "type": "window", "name": "winder", "inverse": True},
-                {"zone": "3", "type": "door"},
-            ],
-            "sensors": [
-                {"zone": "4", "type": "dht"},
-                {"zone": "5", "type": "ds18b20", "name": "temper"},
-            ],
-            "switches": [
-                {
-                    "zone": "out",
-                    "name": "switcher",
-                    "activation": "low",
-                    "momentary": 50,
-                    "pause": 100,
-                    "repeat": 4,
-                },
-                {"zone": "6"},
-            ],
-        }
-    )
-
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Alarm Panel",
-        data=device_config,
-        options=device_options,
-    )
-    entry.add_to_hass(hass)
-
-    # override get_status to reflect non-pro board
-    mock_panel.get_status.return_value = {
-        "hwVersion": "2.3.0",
-        "swVersion": "2.3.1",
-        "heap": 10000,
-        "uptime": 12222,
-        "ip": "192.168.1.90",
-        "port": 9123,
-        "sensors": [],
-        "actuators": [],
-        "dht_sensors": [],
-        "ds18b20_sensors": [],
-        "mac": "11:22:33:44:55:66",
-        "settings": {},
-    }
-
-    # setup the integration and inspect panel behavior
-    assert (
-        await async_setup_component(
-            hass,
-            panel.DOMAIN,
-            {
-                panel.DOMAIN: {
-                    panel.CONF_ACCESS_TOKEN: "arandomstringvalue",
-                    panel.CONF_API_HOST: "http://192.168.1.1:8123",
-                }
-            },
-        )
-        is True
-    )
-
-    # confirm panel instance was created and configured
-    # hass.data is the only mechanism to get a reference to the created panel instance
-    device = hass.data[panel.DOMAIN][panel.CONF_DEVICES]["112233445566"]["panel"]
-    await device.update_switch("1", 0)
-
-    # confirm the correct api is used
-    assert mock_panel.put_device.call_count == 1
-    assert mock_panel.put_zone.call_count == 0
-
-    # confirm the settings are sent to the panel
-    assert mock_panel.put_settings.call_args_list[0][1] == {
-        "sensors": [{"pin": "1"}, {"pin": "2"}, {"pin": "5"}],
-        "actuators": [{"trigger": 0, "pin": "8"}, {"trigger": 1, "pin": "9"}],
-        "dht_sensors": [{"poll_interval": 3, "pin": "6"}],
-        "ds18b20_sensors": [{"poll_interval": 3, "pin": "7"}],
-        "auth_token": "11223344556677889900",
-        "blink": True,
-        "discovery": True,
-        "endpoint": "http://192.168.1.1:8123/api/konnected",
-    }
-
-    # confirm the device settings are saved in hass.data
-    # This test should not access hass.data since its integration internals
-    assert device.stored_configuration == {
-        "binary_sensors": {
-            "1": {
-                "entity_id": (
-                    "binary_sensor.konnected_alarm_panel_konnected_445566_zone_1"
-                ),
-                "inverse": False,
-                "name": "Konnected 445566 Zone 1",
-                "state": None,
-                "type": "door",
-            },
-            "2": {
-                "entity_id": "binary_sensor.konnected_alarm_panel_winder",
-                "inverse": True,
-                "name": "winder",
-                "state": None,
-                "type": "window",
-            },
-            "3": {
-                "entity_id": (
-                    "binary_sensor.konnected_alarm_panel_konnected_445566_zone_3"
-                ),
-                "inverse": False,
-                "name": "Konnected 445566 Zone 3",
-                "state": None,
-                "type": "door",
-            },
-        },
-        "blink": True,
-        "discovery": True,
-        "host": "1.2.3.4",
-        "panel": device,
-        "port": 1234,
-        "sensors": [
-            {
-                "humidity": (
-                    "sensor.konnected_alarm_panel_konnected_445566_sensor_4_humidity"
-                ),
-                "name": "Konnected 445566 Sensor 4",
-                "poll_interval": 3,
-                "temperature": (
-                    "sensor.konnected_alarm_panel_konnected_445566_sensor_4_temperature"
-                ),
-                "type": "dht",
-                "zone": "4",
-            },
-            {"name": "temper", "poll_interval": 3, "type": "ds18b20", "zone": "5"},
-        ],
-        "switches": [
-            {
-                "activation": "low",
-                "entity_id": "switch.konnected_alarm_panel_switcher",
-                "momentary": 50,
-                "name": "switcher",
-                "pause": 100,
-                "repeat": 4,
-                "state": None,
-                "zone": "out",
-            },
-            {
-                "activation": "high",
-                "entity_id": "switch.konnected_alarm_panel_konnected_445566_actuator_6",
-                "momentary": None,
-                "name": "Konnected 445566 Actuator 6",
-                "pause": None,
-                "repeat": None,
-                "state": None,
-                "zone": "6",
-            },
-        ],
-    }
-
-
-async def test_create_and_setup_pro(hass: HomeAssistant, mock_panel) -> None:
-    """Test that we create a Konnected Pro Panel and save the data."""
-    device_config = config_flow.CONFIG_ENTRY_SCHEMA(
-        {
-            "host": "1.2.3.4",
-            "port": 1234,
-            "id": "112233445566",
-            "model": "Konnected Pro",
-            "access_token": "11223344556677889900",
-            "default_options": config_flow.OPTIONS_SCHEMA({config_flow.CONF_IO: {}}),
-        }
-    )
-
-    device_options = config_flow.OPTIONS_SCHEMA(
-        {
-            "io": {
-                "2": "Binary Sensor",
-                "6": "Binary Sensor",
-                "10": "Binary Sensor",
-                "11": "Binary Sensor",
-                "3": "Digital Sensor",
-                "7": "Digital Sensor",
-                "4": "Switchable Output",
-                "8": "Switchable Output",
-                "out1": "Switchable Output",
-                "alarm1": "Switchable Output",
-            },
-            "binary_sensors": [
-                {"zone": "2", "type": "door"},
-                {"zone": "6", "type": "window", "name": "winder", "inverse": True},
-                {"zone": "10", "type": "door"},
-                {"zone": "11", "type": "window"},
-            ],
-            "sensors": [
-                {"zone": "3", "type": "dht", "poll_interval": 5},
-                {"zone": "7", "type": "ds18b20", "poll_interval": 1, "name": "temper"},
-            ],
-            "switches": [
-                {"zone": "4"},
-                {
-                    "zone": "8",
-                    "name": "switcher",
-                    "activation": "low",
-                    "momentary": 50,
-                    "pause": 100,
-                    "repeat": 4,
-                },
-                {"zone": "out1"},
-                {"zone": "alarm1"},
-            ],
-        }
-    )
-
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Pro Alarm Panel",
-        data=device_config,
-        options=device_options,
-    )
-    entry.add_to_hass(hass)
-
-    # setup the integration and inspect panel behavior
-    assert (
-        await async_setup_component(
-            hass,
-            panel.DOMAIN,
-            {
-                panel.DOMAIN: {
-                    panel.CONF_ACCESS_TOKEN: "arandomstringvalue",
-                    panel.CONF_API_HOST: "http://192.168.1.1:8123",
-                }
-            },
-        )
-        is True
-    )
-
-    # confirm panel instance was created and configured
-    # hass.data is the only mechanism to get a reference to the created panel instance
-    device = hass.data[panel.DOMAIN][panel.CONF_DEVICES]["112233445566"]["panel"]
-    await device.update_switch("2", 1)
-
-    # confirm the correct api is used
-    assert mock_panel.put_device.call_count == 0
-    assert mock_panel.put_zone.call_count == 1
-
-    # confirm the settings are sent to the panel
-    assert mock_panel.put_settings.call_args_list[0][1] == {
-        "sensors": [{"zone": "2"}, {"zone": "6"}, {"zone": "10"}, {"zone": "11"}],
-        "actuators": [
-            {"trigger": 1, "zone": "4"},
-            {"trigger": 0, "zone": "8"},
-            {"trigger": 1, "zone": "out1"},
-            {"trigger": 1, "zone": "alarm1"},
-        ],
-        "dht_sensors": [{"poll_interval": 5, "zone": "3"}],
-        "ds18b20_sensors": [{"poll_interval": 1, "zone": "7"}],
-        "auth_token": "11223344556677889900",
-        "blink": True,
-        "discovery": True,
-        "endpoint": "http://192.168.1.1:8123/api/konnected",
-    }
-
-    # confirm the device settings are saved in hass.data
-    # hass.data should not be accessed in tests as its considered integration internals
-    assert device.stored_configuration == {
-        "binary_sensors": {
-            "10": {
-                "entity_id": (
-                    "binary_sensor.konnected_pro_alarm_panel_konnected_445566_zone_10"
-                ),
-                "inverse": False,
-                "name": "Konnected 445566 Zone 10",
-                "state": None,
-                "type": "door",
-            },
-            "11": {
-                "entity_id": (
-                    "binary_sensor.konnected_pro_alarm_panel_konnected_445566_zone_11"
-                ),
-                "inverse": False,
-                "name": "Konnected 445566 Zone 11",
-                "state": None,
-                "type": "window",
-            },
-            "2": {
-                "entity_id": (
-                    "binary_sensor.konnected_pro_alarm_panel_konnected_445566_zone_2"
-                ),
-                "inverse": False,
-                "name": "Konnected 445566 Zone 2",
-                "state": None,
-                "type": "door",
-            },
-            "6": {
-                "entity_id": "binary_sensor.konnected_pro_alarm_panel_winder",
-                "inverse": True,
-                "name": "winder",
-                "state": None,
-                "type": "window",
-            },
-        },
-        "blink": True,
-        "discovery": True,
-        "host": "1.2.3.4",
-        "panel": device,
-        "port": 1234,
-        "sensors": [
-            {
-                "humidity": (
-                    "sensor"
-                    ".konnected_pro_alarm_panel_konnected_445566"
-                    "_sensor_3_humidity"
-                ),
-                "name": "Konnected 445566 Sensor 3",
-                "poll_interval": 5,
-                "temperature": (
-                    "sensor"
-                    ".konnected_pro_alarm_panel_konnected_445566"
-                    "_sensor_3_temperature"
-                ),
-                "type": "dht",
-                "zone": "3",
-            },
-            {"name": "temper", "poll_interval": 1, "type": "ds18b20", "zone": "7"},
-        ],
-        "switches": [
-            {
-                "activation": "high",
-                "entity_id": (
-                    "switch.konnected_pro_alarm_panel_konnected_445566_actuator_4"
-                ),
-                "momentary": None,
-                "name": "Konnected 445566 Actuator 4",
-                "pause": None,
-                "repeat": None,
-                "state": None,
-                "zone": "4",
-            },
-            {
-                "activation": "low",
-                "entity_id": "switch.konnected_pro_alarm_panel_switcher",
-                "momentary": 50,
-                "name": "switcher",
-                "pause": 100,
-                "repeat": 4,
-                "state": None,
-                "zone": "8",
-            },
-            {
-                "activation": "high",
-                "entity_id": (
-                    "switch.konnected_pro_alarm_panel_konnected_445566_actuator_out1"
-                ),
-                "momentary": None,
-                "name": "Konnected 445566 Actuator out1",
-                "pause": None,
-                "repeat": None,
-                "state": None,
-                "zone": "out1",
-            },
-            {
-                "activation": "high",
-                "entity_id": (
-                    "switch.konnected_pro_alarm_panel_konnected_445566_actuator_alarm1"
-                ),
-                "momentary": None,
-                "name": "Konnected 445566 Actuator alarm1",
-                "pause": None,
-                "repeat": None,
-                "state": None,
-                "zone": "alarm1",
-            },
-        ],
-    }
-
-
-async def test_default_options(hass: HomeAssistant, mock_panel) -> None:
-    """Test that we create a Konnected Panel and save the data."""
-    device_config = config_flow.CONFIG_ENTRY_SCHEMA(
-        {
-            "host": "1.2.3.4",
-            "port": 1234,
-            "id": "112233445566",
-            "model": "Konnected Pro",
-            "access_token": "11223344556677889900",
-            "default_options": config_flow.OPTIONS_SCHEMA(
-                {
-                    "io": {
-                        "1": "Binary Sensor",
-                        "2": "Binary Sensor",
-                        "3": "Binary Sensor",
-                        "4": "Digital Sensor",
-                        "5": "Digital Sensor",
-                        "6": "Switchable Output",
-                        "out": "Switchable Output",
-                    },
-                    "binary_sensors": [
-                        {"zone": "1", "type": "door"},
-                        {
-                            "zone": "2",
-                            "type": "window",
-                            "name": "winder",
-                            "inverse": True,
-                        },
-                        {"zone": "3", "type": "door"},
-                    ],
-                    "sensors": [
-                        {"zone": "4", "type": "dht"},
-                        {"zone": "5", "type": "ds18b20", "name": "temper"},
-                    ],
-                    "switches": [
-                        {
-                            "zone": "out",
-                            "name": "switcher",
-                            "activation": "low",
-                            "momentary": 50,
-                            "pause": 100,
-                            "repeat": 4,
-                        },
-                        {"zone": "6"},
-                    ],
-                }
-            ),
-        }
-    )
-
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Alarm Panel",
-        data=device_config,
-        options={},
-    )
-    entry.add_to_hass(hass)
-
-    # override get_status to reflect non-pro board
-    mock_panel.get_status.return_value = {
-        "hwVersion": "2.3.0",
-        "swVersion": "2.3.1",
-        "heap": 10000,
-        "uptime": 12222,
-        "ip": "192.168.1.90",
-        "port": 9123,
-        "sensors": [],
-        "actuators": [],
-        "dht_sensors": [],
-        "ds18b20_sensors": [],
-        "mac": "11:22:33:44:55:66",
-        "settings": {},
-    }
-
-    # setup the integration and inspect panel behavior
-    assert (
-        await async_setup_component(
-            hass,
-            panel.DOMAIN,
-            {
-                panel.DOMAIN: {
-                    panel.CONF_ACCESS_TOKEN: "arandomstringvalue",
-                    panel.CONF_API_HOST: "http://192.168.1.1:8123",
-                }
-            },
-        )
-        is True
-    )
-
-    # confirm panel instance was created and configured.
-    # hass.data is the only mechanism to get a reference to the created panel instance
-    device = hass.data[panel.DOMAIN][panel.CONF_DEVICES]["112233445566"]["panel"]
-    await device.update_switch("1", 0)
-
-    # confirm the correct api is used
-    assert mock_panel.put_device.call_count == 1
-    assert mock_panel.put_zone.call_count == 0
-
-    # confirm the settings are sent to the panel
-    assert mock_panel.put_settings.call_args_list[0][1] == {
-        "sensors": [{"pin": "1"}, {"pin": "2"}, {"pin": "5"}],
-        "actuators": [{"trigger": 0, "pin": "8"}, {"trigger": 1, "pin": "9"}],
-        "dht_sensors": [{"poll_interval": 3, "pin": "6"}],
-        "ds18b20_sensors": [{"poll_interval": 3, "pin": "7"}],
-        "auth_token": "11223344556677889900",
-        "blink": True,
-        "discovery": True,
-        "endpoint": "http://192.168.1.1:8123/api/konnected",
-    }
-
-    # confirm the device settings are saved in hass.data
-    # This test should not access hass.data since its integration internals
-    assert device.stored_configuration == {
-        "binary_sensors": {
-            "1": {
-                "entity_id": (
-                    "binary_sensor.konnected_alarm_panel_konnected_445566_zone_1"
-                ),
-                "inverse": False,
-                "name": "Konnected 445566 Zone 1",
-                "state": None,
-                "type": "door",
-            },
-            "2": {
-                "entity_id": "binary_sensor.konnected_alarm_panel_winder",
-                "inverse": True,
-                "name": "winder",
-                "state": None,
-                "type": "window",
-            },
-            "3": {
-                "entity_id": (
-                    "binary_sensor.konnected_alarm_panel_konnected_445566_zone_3"
-                ),
-                "inverse": False,
-                "name": "Konnected 445566 Zone 3",
-                "state": None,
-                "type": "door",
-            },
-        },
-        "blink": True,
-        "discovery": True,
-        "host": "1.2.3.4",
-        "panel": device,
-        "port": 1234,
-        "sensors": [
-            {
-                "humidity": (
-                    "sensor.konnected_alarm_panel_konnected_445566_sensor_4_humidity"
-                ),
-                "name": "Konnected 445566 Sensor 4",
-                "poll_interval": 3,
-                "temperature": (
-                    "sensor.konnected_alarm_panel_konnected_445566_sensor_4_temperature"
-                ),
-                "type": "dht",
-                "zone": "4",
-            },
-            {"name": "temper", "poll_interval": 3, "type": "ds18b20", "zone": "5"},
-        ],
-        "switches": [
-            {
-                "activation": "low",
-                "entity_id": "switch.konnected_alarm_panel_switcher",
-                "momentary": 50,
-                "name": "switcher",
-                "pause": 100,
-                "repeat": 4,
-                "state": None,
-                "zone": "out",
-            },
-            {
-                "activation": "high",
-                "entity_id": "switch.konnected_alarm_panel_konnected_445566_actuator_6",
-                "momentary": None,
-                "name": "Konnected 445566 Actuator 6",
-                "pause": None,
-                "repeat": None,
-                "state": None,
-                "zone": "6",
-            },
-        ],
-    }
-
-
-async def test_connect_retry(hass: HomeAssistant, mock_panel) -> None:
-    """Test that we create a Konnected Panel and save the data."""
-    device_config = config_flow.CONFIG_ENTRY_SCHEMA(
-        {
-            "host": "1.2.3.4",
-            "port": 1234,
-            "id": "112233445566",
-            "model": "Konnected Pro",
-            "access_token": "11223344556677889900",
-            "default_options": config_flow.OPTIONS_SCHEMA(
-                {
-                    "io": {
-                        "1": "Binary Sensor",
-                        "2": "Binary Sensor",
-                        "3": "Binary Sensor",
-                        "4": "Digital Sensor",
-                        "5": "Digital Sensor",
-                        "6": "Switchable Output",
-                        "out": "Switchable Output",
-                    },
-                    "binary_sensors": [
-                        {"zone": "1", "type": "door"},
-                        {
-                            "zone": "2",
-                            "type": "window",
-                            "name": "winder",
-                            "inverse": True,
-                        },
-                        {"zone": "3", "type": "door"},
-                    ],
-                    "sensors": [
-                        {"zone": "4", "type": "dht"},
-                        {"zone": "5", "type": "ds18b20", "name": "temper"},
-                    ],
-                    "switches": [
-                        {
-                            "zone": "out",
-                            "name": "switcher",
-                            "activation": "low",
-                            "momentary": 50,
-                            "pause": 100,
-                            "repeat": 4,
-                        },
-                        {"zone": "6"},
-                    ],
-                }
-            ),
-        }
-    )
-
-    entry = MockConfigEntry(
-        domain="konnected",
-        title="Konnected Alarm Panel",
-        data=device_config,
-        options={},
-    )
-    entry.add_to_hass(hass)
-
-    # fail first 2 attempts, and succeed the third
-    mock_panel.get_status.side_effect = [
-        mock_panel.ClientError,
-        mock_panel.ClientError,
-        {
-            "hwVersion": "2.3.0",
-            "swVersion": "2.3.1",
-            "heap": 10000,
-            "uptime": 12222,
-            "ip": "192.168.1.90",
-            "port": 9123,
-            "sensors": [],
-            "actuators": [],
-            "dht_sensors": [],
-            "ds18b20_sensors": [],
-            "mac": "11:22:33:44:55:66",
-            "model": "Konnected Pro",
-            "settings": {},
-        },
-    ]
-
-    # setup the integration and inspect panel behavior
-    assert (
-        await async_setup_component(
-            hass,
-            panel.DOMAIN,
-            {
-                panel.DOMAIN: {
-                    panel.CONF_ACCESS_TOKEN: "arandomstringvalue",
-                    panel.CONF_API_HOST: "http://192.168.1.1:8123",
-                }
-            },
-        )
-        is True
-    )
-
-    # confirm switch is unavailable after initial attempt
-    await hass.async_block_till_done()
-    assert hass.states.get("switch.konnected_445566_actuator_6").state == "unavailable"
-
-    # confirm switch is unavailable after second attempt
-    async_fire_time_changed(hass, utcnow() + timedelta(seconds=11))
-    await hass.async_block_till_done()
-    await async_update_entity(hass, "switch.konnected_445566_actuator_6")
-    assert hass.states.get("switch.konnected_445566_actuator_6").state == "unavailable"
-
-    # confirm switch is available after third attempt
-    async_fire_time_changed(hass, utcnow() + timedelta(seconds=21))
-    await hass.async_block_till_done()
-    await async_update_entity(hass, "switch.konnected_445566_actuator_6")
-    assert hass.states.get("switch.konnected_445566_actuator_6").state == "unknown"