Update SANDBOX_COMPAT for newly-installable deps

After 'uv pip install -r requirements_ha.txt' (which pulls in
requirements_all.txt), the integrations previously listed as
'Not Tested (missing dependencies)' import and run:

  - rest: 10/10 pass        (needed xmltodict)
  - logbook: 55/55 pass      (needed sqlalchemy + numpy + turbojpeg)
  - command_line: 7/7 pass
  - trend: 9/9 pass

Promote them into the main pass table; the totals now read 35 of 37
fully pass, 955/957 tests (99.8%).

conversation imports too (hassil was already in pyproject.toml deps
but the report listed it as missing) but 8 of 21 tests fail and the
run deadlocks at tests 20-21 — moved into a new 'Newly runnable, still
investigating' section instead of the pass table.

Add a Setup section pointing at requirements_ha.txt and the pyitachip2ir
macOS caveat.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.gitattributes

@@ -15,6 +15,7 @@ Dockerfile.dev linguist-language=Dockerfile
 # Generated files
 CODEOWNERS linguist-generated=true
 homeassistant/generated/*.py linguist-generated=true
+pylint/plugins/pylint_home_assistant/generated/*.py linguist-generated=true
 machine/* linguist-generated=true
 mypy.ini linguist-generated=true
 requirements.txt linguist-generated=true

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/alexa/entities.py

@@ -39,7 +39,6 @@ from homeassistant.const import (
     ATTR_DEVICE_CLASS,
     ATTR_SUPPORTED_FEATURES,
     ATTR_UNIT_OF_MEASUREMENT,
-    CLOUD_NEVER_EXPOSED_ENTITIES,
     CONF_DESCRIPTION,
     CONF_NAME,
     UnitOfTemperature,
@@ -373,9 +372,6 @@ def async_get_entities(
     """Return all entities that are supported by Alexa."""
     entities: list[AlexaEntity] = []
     for state in hass.states.async_all():
-        if state.entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            continue
-
         if state.domain not in ENTITY_ADAPTERS:
             continue
 

homeassistant/components/arcam_fmj/config_flow.py

@@ -16,6 +16,13 @@ from homeassistant.helpers.service_info.ssdp import ATTR_UPNP_UDN, SsdpServiceIn
 
 from .const import DEFAULT_NAME, DEFAULT_PORT, DOMAIN
 
+STEP_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_HOST): str,
+        vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
+    }
+)
+
 
 class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle config flow."""
@@ -31,13 +38,22 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
         await self.async_set_unique_id(uuid)
         self._abort_if_unique_id_configured({CONF_HOST: host, CONF_PORT: port})
 
-    async def _async_try_connect(self, host: str, port: int) -> None:
-        """Verify the device is reachable."""
+    async def _async_try_connect(self, host: str, port: int) -> dict[str, str]:
+        """Verify the device is reachable; return errors keyed by reason."""
         client = Client(host, port)
         try:
             await client.start()
+        except socket.gaierror:
+            return {"base": "invalid_host"}
+        except TimeoutError:
+            return {"base": "timeout_connect"}
+        except ConnectionRefusedError:
+            return {"base": "connection_refused"}
+        except ConnectionFailed, OSError:
+            return {"base": "cannot_connect"}
         finally:
             await client.stop()
+        return {}
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -53,19 +69,10 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
                     user_input[CONF_HOST], user_input[CONF_PORT], uuid
                 )
 
-            try:
-                await self._async_try_connect(
-                    user_input[CONF_HOST], user_input[CONF_PORT]
-                )
-            except socket.gaierror:
-                errors["base"] = "invalid_host"
-            except TimeoutError:
-                errors["base"] = "timeout_connect"
-            except ConnectionRefusedError:
-                errors["base"] = "connection_refused"
-            except ConnectionFailed, OSError:
-                errors["base"] = "cannot_connect"
-            else:
+            errors = await self._async_try_connect(
+                user_input[CONF_HOST], user_input[CONF_PORT]
+            )
+            if not errors:
                 return self.async_create_entry(
                     title=f"{DEFAULT_NAME} ({user_input[CONF_HOST]})",
                     data={
@@ -74,16 +81,46 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
                     },
                 )
 
-        fields = {
-            vol.Required(CONF_HOST): str,
-            vol.Required(CONF_PORT, default=DEFAULT_PORT): int,
-        }
-        schema = vol.Schema(fields)
+        schema = STEP_DATA_SCHEMA
         if user_input is not None:
             schema = self.add_suggested_values_to_schema(schema, user_input)
 
         return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of an existing entry."""
+        errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+        if user_input is not None:
+            uuid = await get_uniqueid_from_host(
+                async_get_clientsession(self.hass), user_input[CONF_HOST]
+            )
+            if uuid:
+                await self.async_set_unique_id(uuid)
+                self._abort_if_unique_id_mismatch()
+
+            errors = await self._async_try_connect(
+                user_input[CONF_HOST], user_input[CONF_PORT]
+            )
+            if not errors:
+                return self.async_update_reload_and_abort(
+                    reconfigure_entry,
+                    data_updates={
+                        CONF_HOST: user_input[CONF_HOST],
+                        CONF_PORT: user_input[CONF_PORT],
+                    },
+                )
+
+        schema = self.add_suggested_values_to_schema(
+            STEP_DATA_SCHEMA, user_input or reconfigure_entry.data
+        )
+
+        return self.async_show_form(
+            step_id="reconfigure", data_schema=schema, errors=errors
+        )
+
     async def async_step_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -113,9 +150,7 @@ class ArcamFmjFlowHandler(ConfigFlow, domain=DOMAIN):
 
         await self._async_set_unique_id_and_update(host, port, uuid)
 
-        try:
-            await self._async_try_connect(host, port)
-        except ConnectionFailed, OSError:
+        if await self._async_try_connect(host, port):
             return self.async_abort(reason="cannot_connect")
 
         self.host = host

homeassistant/components/arcam_fmj/strings.json

@@ -3,7 +3,9 @@
     "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%]"
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
+      "unique_id_mismatch": "Please ensure you reconfigure against the same device."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -16,6 +18,13 @@
       "confirm": {
         "description": "Do you want to add Arcam FMJ on `{host}` to Home Assistant?"
       },
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "port": "[%key:common::config_flow::data::port%]"
+        },
+        "description": "[%key:component::arcam_fmj::config::step::user::description%]"
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",

homeassistant/components/bluetooth/manifest.json

@@ -21,6 +21,6 @@
     "bluetooth-auto-recovery==1.5.3",
     "bluetooth-data-tools==1.29.11",
     "dbus-fast==5.0.3",
-    "habluetooth==6.2.0"
+    "habluetooth==6.4.0"
   ]
 }

homeassistant/components/cloud/alexa_config.py

@@ -32,7 +32,6 @@ from homeassistant.components.homeassistant.exposed_entities import (
     async_should_expose,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import Event, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er, start
@@ -275,9 +274,6 @@ class CloudAlexaConfig(alexa_config.AbstractConfig):
 
     def _should_expose_legacy(self, entity_id: str) -> bool:
         """If an entity should be exposed."""
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_configs = self._prefs.alexa_entity_configs
         entity_config = entity_configs.get(entity_id, {})
         entity_expose: bool | None = entity_config.get(PREF_SHOULD_EXPOSE)
@@ -308,8 +304,6 @@ class CloudAlexaConfig(alexa_config.AbstractConfig):
         """If an entity should be exposed."""
         entity_filter: EntityFilter = self._config[CONF_FILTER]
         if not entity_filter.empty_filter:
-            if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-                return False
             return entity_filter(entity_id)
 
         return async_should_expose(self.hass, CLOUD_ALEXA, entity_id)

homeassistant/components/cloud/google_config.py

@@ -22,7 +22,6 @@ from homeassistant.components.homeassistant.exposed_entities import (
     async_should_expose,
 )
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import (
     CoreState,
     Event,
@@ -282,9 +281,6 @@ class CloudGoogleConfig(AbstractConfig):
 
     def _should_expose_legacy(self, entity_id: str) -> bool:
         """If an entity ID should be exposed."""
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_configs = self._prefs.google_entity_configs
         entity_config = entity_configs.get(entity_id, {})
         entity_expose: bool | None = entity_config.get(PREF_SHOULD_EXPOSE)
@@ -316,8 +312,6 @@ class CloudGoogleConfig(AbstractConfig):
         """If an entity should be exposed."""
         entity_filter: EntityFilter = self._config[CONF_FILTER]
         if not entity_filter.empty_filter:
-            if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-                return False
             return entity_filter(entity_id)
 
         return async_should_expose(self.hass, CLOUD_GOOGLE, entity_id)

homeassistant/components/cloud/http_api.py

@@ -29,7 +29,6 @@ from homeassistant.components.homeassistant import exposed_entities
 from homeassistant.components.http import KEY_HASS, HomeAssistantView, require_admin
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.components.system_health import get_info as get_system_health_info
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
@@ -973,7 +972,7 @@ async def google_assistant_get(
         return
 
     entity = google_helpers.GoogleEntity(hass, gconf, state)
-    if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES or not entity.is_supported():
+    if not entity.is_supported():
         connection.send_error(
             msg["id"],
             websocket_api.ERR_NOT_SUPPORTED,
@@ -1075,9 +1074,7 @@ async def alexa_get(
     """Get data for a single alexa entity."""
     entity_id: str = msg["entity_id"]
 
-    if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES or not entity_supported_by_alexa(
-        hass, entity_id
-    ):
+    if not entity_supported_by_alexa(hass, entity_id):
         connection.send_error(
             msg["id"],
             websocket_api.ERR_NOT_SUPPORTED,

homeassistant/components/esphome/manifest.json

@@ -17,9 +17,9 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==45.0.4",
+    "aioesphomeapi==45.1.0",
     "esphome-dashboard-api==1.3.0",
-    "bleak-esphome==3.7.3"
+    "bleak-esphome==3.8.1"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/flo/entity.py

@@ -10,7 +10,6 @@ from .coordinator import FloDeviceDataUpdateCoordinator
 class FloEntity(Entity):
     """A base class for Flo entities."""
 
-    _attr_force_update = False
     _attr_has_entity_name = True
     _attr_should_poll = False
 

homeassistant/components/google_assistant/helpers.py

@@ -18,7 +18,6 @@ from homeassistant.components import webhook
 from homeassistant.const import (
     ATTR_DEVICE_CLASS,
     ATTR_SUPPORTED_FEATURES,
-    CLOUD_NEVER_EXPOSED_ENTITIES,
     CONF_NAME,
     STATE_UNAVAILABLE,
 )
@@ -803,8 +802,6 @@ def async_get_entities(
     is_supported_cache = config.is_supported_cache
     for state in hass.states.async_all():
         entity_id = state.entity_id
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            continue
         # Check check inlined for performance to avoid
         # function calls for every entity since we enumerate
         # the entire state machine here

homeassistant/components/google_assistant/http.py

@@ -12,7 +12,6 @@ import jwt
 
 from homeassistant.components import webhook
 from homeassistant.components.http import KEY_HASS, HomeAssistantView
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
@@ -167,9 +166,6 @@ class GoogleConfig(AbstractConfig):
             # Ignore entities that are views
             return False
 
-        if state.entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_registry = er.async_get(self.hass)
         registry_entry = entity_registry.async_get(state.entity_id)
         if registry_entry:

homeassistant/components/heos/config_flow.py

@@ -116,7 +116,7 @@ async def _validate_auth(
 
 def _get_current_hosts(entry: HeosConfigEntry) -> set[str]:
     """Get a set of current hosts from the entry."""
-    hosts = set(entry.data[CONF_HOST])
+    hosts = {entry.data[CONF_HOST]}
     if hasattr(entry, "runtime_data"):
         hosts.update(
             player.ip_address

homeassistant/components/heos/media_player.py

@@ -473,6 +473,7 @@ class HeosMediaPlayer(CoordinatorEntity[HeosCoordinator], MediaPlayerEntity):
                 await self.coordinator.heos.set_group(new_members)
                 return
 
+    @catch_action_error("remove from queue")
     async def async_remove_from_queue(self, queue_ids: list[int]) -> None:
         """Remove items from the queue."""
         await self._player.remove_from_queue(queue_ids)

homeassistant/components/homeassistant/exposed_entities.py

@@ -10,7 +10,6 @@ import voluptuous as vol
 from homeassistant.components import websocket_api
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.const import CLOUD_NEVER_EXPOSED_ENTITIES
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
@@ -246,9 +245,6 @@ class ExposedEntities:
         """Return True if an entity should be exposed to an assistant."""
         should_expose: bool
 
-        if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES:
-            return False
-
         entity_registry = er.async_get(self._hass)
         if not (registry_entry := entity_registry.async_get(entity_id)):
             return self._async_should_expose_legacy_entity(assistant, entity_id)
@@ -406,19 +402,6 @@ def ws_expose_entity(
     """Expose an entity to an assistant."""
     entity_ids: list[str] = msg["entity_ids"]
 
-    if blocked := next(
-        (
-            entity_id
-            for entity_id in entity_ids
-            if entity_id in CLOUD_NEVER_EXPOSED_ENTITIES
-        ),
-        None,
-    ):
-        connection.send_error(
-            msg["id"], websocket_api.ERR_NOT_ALLOWED, f"can't expose '{blocked}'"
-        )
-        return
-
     for entity_id in entity_ids:
         for assistant in msg["assistants"]:
             async_expose_entity(hass, assistant, entity_id, msg["should_expose"])

homeassistant/components/homeassistant_connect_zbt2/hardware.py

@@ -19,7 +19,9 @@ EXPECTED_ENTRY_VERSION = (
 @callback
 def async_info(hass: HomeAssistant) -> list[HardwareInfo]:
     """Return board info."""
-    entries = hass.config_entries.async_entries(DOMAIN)
+    entries = hass.config_entries.async_entries(
+        DOMAIN, include_ignore=False, include_disabled=False
+    )
     return [
         HardwareInfo(
             board=None,

homeassistant/components/homewizard/manifest.json

@@ -13,6 +13,6 @@
   "iot_class": "local_polling",
   "loggers": ["homewizard_energy"],
   "quality_scale": "platinum",
-  "requirements": ["python-homewizard-energy==10.0.1"],
+  "requirements": ["python-homewizard-energy==10.1.0"],
   "zeroconf": ["_hwenergy._tcp.local.", "_homewizard._tcp.local."]
 }

homeassistant/components/homewizard/sensor.py

@@ -35,7 +35,6 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.util.dt import utcnow
-from homeassistant.util.variance import ignore_variance
 
 from .const import DOMAIN
 from .coordinator import HomeWizardConfigEntry, HWEnergyDeviceUpdateCoordinator
@@ -66,13 +65,6 @@ def to_percentage(value: float | None) -> float | None:
     return value * 100 if value is not None else None
 
 
-def uptime_to_datetime(value: int) -> datetime:
-    """Convert seconds to datetime timestamp."""
-    return utcnow().replace(microsecond=0) - timedelta(seconds=value)
-
-
-uptime_to_stable_datetime = ignore_variance(uptime_to_datetime, timedelta(minutes=5))
-
 SENSORS: Final[tuple[HomeWizardSensorEntityDescription, ...]] = (
     HomeWizardSensorEntityDescription(
         key="smr_version",
@@ -643,7 +635,7 @@ SENSORS: Final[tuple[HomeWizardSensorEntityDescription, ...]] = (
     HomeWizardSensorEntityDescription(
         key="uptime",
         translation_key="uptime",
-        device_class=SensorDeviceClass.TIMESTAMP,
+        device_class=SensorDeviceClass.UPTIME,
         entity_category=EntityCategory.DIAGNOSTIC,
         entity_registry_enabled_default=False,
         has_fn=(
@@ -651,7 +643,7 @@ SENSORS: Final[tuple[HomeWizardSensorEntityDescription, ...]] = (
         ),
         value_fn=(
             lambda data: (
-                uptime_to_stable_datetime(data.system.uptime_s)
+                utcnow() - timedelta(seconds=data.system.uptime_s)
                 if data.system is not None and data.system.uptime_s is not None
                 else None
             )

homeassistant/components/homewizard/strings.json

@@ -61,13 +61,14 @@
     },
     "select": {
       "battery_group_mode": {
-        "name": "Battery group mode",
+        "name": "Battery group charging strategy",
         "state": {
+          "predictive": "Smart charging",
           "standby": "Standby",
-          "to_full": "Manual charge mode",
-          "zero": "Zero mode",
-          "zero_charge_only": "Zero mode (charge only)",
-          "zero_discharge_only": "Zero mode (discharge only)"
+          "to_full": "One-time full charge",
+          "zero": "Net zero",
+          "zero_charge_only": "Net zero (charge only)",
+          "zero_discharge_only": "Net zero (discharge only)"
         }
       }
     },

homeassistant/components/hue/v2/device_trigger.py

@@ -87,6 +87,8 @@ def async_get_triggers(
 
     # Get Hue device id from device identifier
     hue_dev_id = get_hue_device_id(device_entry)
+    if hue_dev_id is None or hue_dev_id not in api.devices:
+        return []
     # extract triggers from all button resources of this Hue device
     triggers: list[dict[str, Any]] = []
     model_id = api.devices[hue_dev_id].product_data.product_name

homeassistant/components/insteon/__init__.py

@@ -118,6 +118,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         )
         device = devices.add_x10_device(housecode, unitcode, x10_type, steps)
 
+    create_insteon_device(hass, devices.modem, entry.entry_id)
+
     await hass.config_entries.async_forward_entry_setups(entry, INSTEON_PLATFORMS)
 
     for address in devices:
@@ -131,8 +133,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     register_new_device_callback(hass)
     async_setup_services(hass)
 
-    create_insteon_device(hass, devices.modem, entry.entry_id)
-
     entry.async_create_background_task(
         hass, async_get_device_config(hass, entry), "insteon-get-device-config"
     )

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/components/light/__init__.py

@@ -241,7 +241,7 @@ def preprocess_turn_on_alternatives(
 
     if (color_name := params.pop(ATTR_COLOR_NAME, None)) is not None:
         try:
-            params[ATTR_RGB_COLOR] = color_util.color_name_to_rgb(color_name)
+            params[ATTR_RGB_COLOR] = tuple(color_util.color_name_to_rgb(color_name))
         except ValueError:
             _LOGGER.warning("Got unknown color %s, falling back to white", color_name)
             params[ATTR_RGB_COLOR] = (255, 255, 255)

homeassistant/components/matter/__init__.py

@@ -60,7 +60,7 @@ def get_matter_device_info(
         return None
 
     return MatterDeviceInfo(
-        unique_id=node.device_info.uniqueID,
+        unique_id=node.device_info.uniqueID or "",
         vendor_id=hex(node.device_info.vendorID),
         product_id=hex(node.device_info.productID),
     )

homeassistant/components/matter/diagnostics.py

@@ -6,13 +6,14 @@ from typing import Any
 from chip.clusters import Objects
 from matter_server.common.helpers.util import dataclass_to_dict, parse_attribute_path
 
-from homeassistant.components.diagnostics import REDACTED
+from homeassistant.components.diagnostics import REDACTED, async_redact_data
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 
 from .helpers import MatterConfigEntry, get_matter, get_node_from_device_entry
 
 ATTRIBUTES_TO_REDACT = {Objects.BasicInformation.Attributes.Location}
+SERVER_INFO_TO_REDACT = {"wifi_ssid"}
 
 
 def redact_matter_attributes(node_data: dict[str, Any]) -> dict[str, Any]:
@@ -44,6 +45,7 @@ async def async_get_config_entry_diagnostics(
     matter = get_matter(hass)
     server_diagnostics = await matter.matter_client.get_diagnostics()
     data = dataclass_to_dict(server_diagnostics)
+    data["info"] = async_redact_data(data["info"], SERVER_INFO_TO_REDACT)
     nodes = [redact_matter_attributes(node_data) for node_data in data["nodes"]]
     data["nodes"] = nodes
 
@@ -59,7 +61,9 @@ async def async_get_device_diagnostics(
     node = get_node_from_device_entry(hass, device)
 
     return {
-        "server_info": dataclass_to_dict(server_diagnostics.info),
+        "server_info": async_redact_data(
+            dataclass_to_dict(server_diagnostics.info), SERVER_INFO_TO_REDACT
+        ),
         "node": redact_matter_attributes(
             remove_serialization_type(dataclass_to_dict(node.node_data) if node else {})
         ),

homeassistant/components/matter/manifest.json

@@ -8,6 +8,6 @@
   "documentation": "https://www.home-assistant.io/integrations/matter",
   "integration_type": "hub",
   "iot_class": "local_push",
-  "requirements": ["matter-python-client==0.6.0"],
+  "requirements": ["matter-python-client==0.7.1"],
   "zeroconf": ["_matter._tcp.local.", "_matterc._udp.local."]
 }

homeassistant/components/motioneye/camera.py

@@ -29,6 +29,7 @@ from homeassistant.components.mjpeg import (
     MjpegCamera,
 )
 from homeassistant.const import (
+    CONF_ACTION,
     CONF_AUTHENTICATION,
     CONF_NAME,
     CONF_PASSWORD,
@@ -43,7 +44,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import get_camera_from_cameras, is_acceptable_camera, listen_for_new_cameras
 from .const import (
-    CONF_ACTION,
     CONF_STREAM_URL_TEMPLATE,
     CONF_SURVEILLANCE_PASSWORD,
     CONF_SURVEILLANCE_USERNAME,

homeassistant/components/motioneye/const.py

@@ -29,8 +29,6 @@ DOMAIN: Final = "motioneye"
 ATTR_EVENT_TYPE: Final = "event_type"
 ATTR_WEBHOOK_ID: Final = "webhook_id"
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_ACTION: Final = "action"
 CONF_ADMIN_PASSWORD: Final = "admin_password"
 CONF_ADMIN_USERNAME: Final = "admin_username"
 CONF_MORE_OPTIONS: Final = "more_options"

homeassistant/components/mqtt/abbreviations.py

@@ -108,6 +108,7 @@ ABBREVIATIONS = {
     "mode_stat_t": "mode_state_topic",
     "mode_stat_tpl": "mode_state_template",
     "modes": "modes",
+    "msg_exp_int": "message_expiry_interval",
     "name": "name",
     "o": "origin",
     "off_dly": "off_delay",

homeassistant/components/mqtt/config_flow.py

@@ -120,6 +120,8 @@ from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.json import json_dumps
 from homeassistant.helpers.selector import (
     BooleanSelector,
+    DurationSelector,
+    DurationSelectorConfig,
     FileSelector,
     FileSelectorConfig,
     NumberSelector,
@@ -227,6 +229,7 @@ from .const import (
     CONF_LAST_RESET_VALUE_TEMPLATE,
     CONF_MAX,
     CONF_MAX_KELVIN,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_MIN,
     CONF_MIN_KELVIN,
     CONF_MODE_COMMAND_TEMPLATE,
@@ -3721,6 +3724,11 @@ MQTT_DEVICE_PLATFORM_FIELDS = {
         default=DEFAULT_QOS,
         section="mqtt_settings",
     ),
+    CONF_MESSAGE_EXPIRY_INTERVAL: PlatformField(
+        selector=DurationSelector(DurationSelectorConfig(enable_day=True)),
+        required=False,
+        section="mqtt_settings",
+    ),
 }
 
 

homeassistant/components/mqtt/const.py

@@ -49,6 +49,7 @@ CONF_IMAGE_TOPIC = "image_topic"
 CONF_JSON_ATTRS_TOPIC = "json_attributes_topic"
 CONF_JSON_ATTRS_TEMPLATE = "json_attributes_template"
 CONF_KEEPALIVE = "keepalive"
+CONF_MESSAGE_EXPIRY_INTERVAL = "message_expiry_interval"
 CONF_ORIGIN = "origin"
 CONF_QOS = ATTR_QOS
 CONF_RETAIN = ATTR_RETAIN

homeassistant/components/mqtt/debug_info.py

@@ -17,7 +17,7 @@ from .models import DATA_MQTT, PublishPayloadType
 STORED_MESSAGES = 10
 
 
-@dataclass
+@dataclass(frozen=True, slots=True)
 class TimestampedPublishMessage:
     """MQTT Message."""
 
@@ -26,6 +26,8 @@ class TimestampedPublishMessage:
     qos: int
     retain: bool
     timestamp: float
+    encoding: str | None
+    kwargs: dict[str, Any]
 
 
 def log_message(
@@ -35,6 +37,8 @@ def log_message(
     payload: PublishPayloadType,
     qos: int,
     retain: bool,
+    encoding: str | None,
+    **kwargs: Any,
 ) -> None:
     """Log an outgoing MQTT message."""
     entity_info = hass.data[DATA_MQTT].debug_info_entities.setdefault(
@@ -45,7 +49,13 @@ def log_message(
             "messages": deque(maxlen=STORED_MESSAGES),
         }
     msg = TimestampedPublishMessage(
-        topic, payload, qos, retain, timestamp=time.monotonic()
+        topic,
+        payload,
+        qos,
+        retain,
+        timestamp=time.monotonic(),
+        encoding=encoding,
+        kwargs=kwargs,
     )
     entity_info["transmitted"][topic]["messages"].append(msg)
 

homeassistant/components/mqtt/entity.py

@@ -84,6 +84,7 @@ from .const import (
     CONF_JSON_ATTRS_TEMPLATE,
     CONF_JSON_ATTRS_TOPIC,
     CONF_MANUFACTURER,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_PAYLOAD_AVAILABLE,
     CONF_PAYLOAD_NOT_AVAILABLE,
     CONF_QOS,
@@ -94,7 +95,6 @@ from .const import (
     CONF_SW_VERSION,
     CONF_TOPIC,
     CONF_VIA_DEVICE,
-    DEFAULT_ENCODING,
     DOMAIN,
     MQTT_CONNECTION_STATE,
 )
@@ -153,6 +153,8 @@ MQTT_ATTRIBUTES_BLOCKED = {
     "unit_of_measurement",
 }
 
+PUBLISH_KWARGS = (CONF_MESSAGE_EXPIRY_INTERVAL,)
+
 
 @callback
 def async_handle_schema_error(
@@ -1539,36 +1541,20 @@ class MqttEntity(
         await MqttDiscoveryUpdateMixin.async_will_remove_from_hass(self)
         debug_info.remove_entity_data(self.hass, self.entity_id)
 
-    async def async_publish(
-        self,
-        topic: str,
-        payload: PublishPayloadType,
-        qos: int = 0,
-        retain: bool = False,
-        encoding: str | None = DEFAULT_ENCODING,
-    ) -> None:
-        """Publish message to an MQTT topic."""
-        log_message(self.hass, self.entity_id, topic, payload, qos, retain)
-        await async_publish(
-            self.hass,
-            topic,
-            payload,
-            qos,
-            retain,
-            encoding,
-        )
-
     async def async_publish_with_config(
         self, topic: str, payload: PublishPayloadType
     ) -> None:
         """Publish payload to a topic using config."""
-        await self.async_publish(
-            topic,
-            payload,
-            self._config[CONF_QOS],
-            self._config[CONF_RETAIN],
-            self._config[CONF_ENCODING],
+        kwargs: dict[str, Any] = {
+            key: value for key, value in self._config.items() if key in PUBLISH_KWARGS
+        }
+        qos: int = self._config[CONF_QOS]
+        retain: bool = self._config[CONF_RETAIN]
+        encoding: str = self._config[CONF_ENCODING]
+        log_message(
+            self.hass, self.entity_id, topic, payload, qos, retain, encoding, **kwargs
         )
+        await async_publish(self.hass, topic, payload, qos, retain, encoding, **kwargs)
 
     @staticmethod
     @abstractmethod

homeassistant/components/mqtt/models.py

@@ -509,10 +509,20 @@ class MqttComponentConfig:
     discovery_payload: MQTTDiscoveryPayload
 
 
+class MessageExpiryInterval(TypedDict, total=False):
+    """Hold the Message Expiry Interval."""
+
+    days: float
+    hours: float
+    minutes: float
+    seconds: float
+
+
 class DeviceMqttOptions(TypedDict, total=False):
     """Hold the shared MQTT specific options for an MQTT device."""
 
     qos: int
+    message_expiry_interval: MessageExpiryInterval
 
 
 class MqttDeviceData(TypedDict, total=False):

homeassistant/components/mqtt/schemas.py

@@ -40,6 +40,7 @@ from .const import (
     CONF_JSON_ATTRS_TEMPLATE,
     CONF_JSON_ATTRS_TOPIC,
     CONF_MANUFACTURER,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_ORIGIN,
     CONF_PAYLOAD_AVAILABLE,
     CONF_PAYLOAD_NOT_AVAILABLE,
@@ -66,6 +67,7 @@ SHARED_OPTIONS = [
     CONF_AVAILABILITY_TOPIC,
     CONF_COMMAND_TOPIC,
     CONF_ENCODING,
+    CONF_MESSAGE_EXPIRY_INTERVAL,
     CONF_PAYLOAD_AVAILABLE,
     CONF_PAYLOAD_NOT_AVAILABLE,
     CONF_STATE_TOPIC,
@@ -161,6 +163,14 @@ MQTT_ORIGIN_INFO_SCHEMA = vol.All(
     ),
 )
 
+
+def valid_message_expiry_interval(value: Any) -> int:
+    """Return Message Expiry Interval in seconds."""
+    if isinstance(value, int):
+        return cv.positive_int(value)  # type: ignore[no-any-return]
+    return int(cv.positive_time_period_dict(value).total_seconds())
+
+
 MQTT_ENTITY_COMMON_SCHEMA = _MQTT_AVAILABILITY_SCHEMA.extend(
     {
         vol.Optional(CONF_DEVICE): MQTT_ENTITY_DEVICE_INFO_SCHEMA,
@@ -172,6 +182,7 @@ MQTT_ENTITY_COMMON_SCHEMA = _MQTT_AVAILABILITY_SCHEMA.extend(
         vol.Optional(CONF_JSON_ATTRS_TOPIC): valid_subscribe_topic,
         vol.Optional(CONF_JSON_ATTRS_TEMPLATE): cv.template,
         vol.Optional(CONF_DEFAULT_ENTITY_ID): cv.string,
+        vol.Optional(CONF_MESSAGE_EXPIRY_INTERVAL): valid_message_expiry_interval,
         vol.Optional(CONF_UNIQUE_ID): cv.string,
     }
 )
@@ -203,6 +214,7 @@ DEVICE_DISCOVERY_SCHEMA = _MQTT_AVAILABILITY_SCHEMA.extend(
         vol.Required(CONF_ORIGIN): MQTT_ORIGIN_INFO_SCHEMA,
         vol.Optional(CONF_STATE_TOPIC): valid_subscribe_topic,
         vol.Optional(CONF_COMMAND_TOPIC): valid_publish_topic,
+        vol.Optional(CONF_MESSAGE_EXPIRY_INTERVAL): valid_message_expiry_interval,
         vol.Optional(CONF_QOS): valid_qos_schema,
         vol.Optional(CONF_ENCODING): cv.string,
     }

homeassistant/components/mqtt/strings.json

@@ -197,9 +197,11 @@
             },
             "mqtt_settings": {
               "data": {
+                "message_expiry_interval": "Message Expiry Interval",
                 "qos": "QoS"
               },
               "data_description": {
+                "message_expiry_interval": "Retention time interval for published message.",
                 "qos": "The Quality of Service value the device's entities should use."
               },
               "name": "MQTT settings"

homeassistant/components/netatmo/camera.py

@@ -10,6 +10,7 @@ from pyatmo.event import Event as NaEvent
 import voluptuous as vol
 
 from homeassistant.components.camera import Camera, CameraEntityFeature
+from homeassistant.const import ATTR_PERSONS
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, entity_platform
@@ -20,7 +21,6 @@ from .const import (
     ATTR_CAMERA_LIGHT_MODE,
     ATTR_EVENT_TYPE,
     ATTR_PERSON,
-    ATTR_PERSONS,
     CAMERA_LIGHT_MODES,
     CAMERA_TRIGGERS,
     CONF_URL_SECURITY,

homeassistant/components/netatmo/const.py

@@ -92,8 +92,6 @@ ATTR_HOME_ID = "home_id"
 ATTR_HOME_NAME = "home_name"
 ATTR_IS_KNOWN = "is_known"
 ATTR_PERSON = "person"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_PERSONS = "persons"
 ATTR_PSEUDO = "pseudo"
 ATTR_SCHEDULE_ID = "schedule_id"
 ATTR_SCHEDULE_NAME = "schedule_name"

homeassistant/components/netatmo/webhook.py

@@ -5,7 +5,7 @@ import logging
 
 from aiohttp.web import Request
 
-from homeassistant.const import ATTR_DEVICE_ID, ATTR_ID, ATTR_NAME
+from homeassistant.const import ATTR_DEVICE_ID, ATTR_ID, ATTR_NAME, ATTR_PERSONS
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
@@ -14,7 +14,6 @@ from .const import (
     ATTR_FACE_URL,
     ATTR_HOME_ID,
     ATTR_IS_KNOWN,
-    ATTR_PERSONS,
     DATA_DEVICE_IDS,
     DATA_PERSONS,
     DEFAULT_PERSON,

homeassistant/components/nice_go/const.py

@@ -8,8 +8,6 @@ DOMAIN = "nice_go"
 
 # Configuration
 CONF_SITE_ID = "site_id"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_DEVICE_ID = "device_id"
 CONF_REFRESH_TOKEN = "refresh_token"
 CONF_REFRESH_TOKEN_CREATION_TIME = "refresh_token_creation_time"
 

homeassistant/components/nina/binary_sensor.py

@@ -6,6 +6,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
+from homeassistant.const import ATTR_ID
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -14,7 +15,6 @@ from .const import (
     ATTR_DESCRIPTION,
     ATTR_EXPIRES,
     ATTR_HEADLINE,
-    ATTR_ID,
     ATTR_RECOMMENDED_ACTIONS,
     ATTR_SENDER,
     ATTR_SENT,

homeassistant/components/nina/const.py

@@ -29,8 +29,6 @@ ATTR_SEVERITY: str = "severity"
 ATTR_RECOMMENDED_ACTIONS: str = "recommended_actions"
 ATTR_AFFECTED_AREAS: str = "affected_areas"
 ATTR_WEB: str = "web"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_ID: str = "id"
 ATTR_SENT: str = "sent"
 ATTR_START: str = "start"
 ATTR_EXPIRES: str = "expires"

homeassistant/components/nmbs/config_flow.py

@@ -7,6 +7,7 @@ from pyrail.models import StationDetails
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_SHOW_ON_MAP
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import (
     BooleanSelector,
@@ -16,13 +17,7 @@ from homeassistant.helpers.selector import (
     SelectSelectorMode,
 )
 
-from .const import (
-    CONF_EXCLUDE_VIAS,
-    CONF_SHOW_ON_MAP,
-    CONF_STATION_FROM,
-    CONF_STATION_TO,
-    DOMAIN,
-)
+from .const import CONF_EXCLUDE_VIAS, CONF_STATION_FROM, CONF_STATION_TO, DOMAIN
 
 
 class NMBSConfigFlow(ConfigFlow, domain=DOMAIN):

homeassistant/components/nmbs/const.py

@@ -13,8 +13,6 @@ CONF_STATION_FROM = "station_from"
 CONF_STATION_TO = "station_to"
 CONF_STATION_LIVE = "station_live"
 CONF_EXCLUDE_VIAS = "exclude_vias"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_SHOW_ON_MAP = "show_on_map"
 
 
 def find_station_by_name(hass: HomeAssistant, station_name: str):

homeassistant/components/novy_cooker_hood/config_flow.py

@@ -3,7 +3,7 @@
 import asyncio
 from typing import Any
 
-from rf_protocols.commands.novy import NovyCookerHoodCommand
+from rf_protocols.codes.novy.cooker_hood import get_codes_for_code
 import voluptuous as vol
 
 from homeassistant.components.radio_frequency import (
@@ -128,8 +128,10 @@ class NovyCookerHoodConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Toggle the hood light on then off so it ends in its starting state."""
         assert self._transmitter_entity_id is not None
-        command = NovyCookerHoodCommand(channel=self._code, key=COMMAND_LIGHT)
         try:
+            command = await get_codes_for_code(self._code).async_load_command(
+                COMMAND_LIGHT
+            )
             await async_send_command(self.hass, self._transmitter_entity_id, command)
             await asyncio.sleep(_TOGGLE_GAP)
             await async_send_command(self.hass, self._transmitter_entity_id, command)

homeassistant/components/novy_cooker_hood/fan.py

@@ -1,10 +1,9 @@
 """Fan platform for the Novy Cooker Hood (calibrated speed control)."""
 
-import asyncio
 import math
 from typing import Any
 
-from rf_protocols.commands.novy import NovyCookerHoodCommand
+from rf_protocols.codes.novy.cooker_hood import get_codes_for_code
 
 from homeassistant.components.fan import ATTR_PERCENTAGE, FanEntity, FanEntityFeature
 from homeassistant.components.radio_frequency import async_send_command
@@ -26,9 +25,6 @@ PARALLEL_UPDATES = 1
 
 _SPEED_RANGE = (1, SPEED_COUNT)
 
-# Novy hood expects at least 150ms between RF commands
-_COMMAND_DELAY = 0.2
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -53,7 +49,7 @@ class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
     def __init__(self, entry: ConfigEntry) -> None:
         """Initialize the fan."""
         super().__init__(entry)
-        self._code: int = entry.data[CONF_CODE]
+        self._codes = get_codes_for_code(entry.data[CONF_CODE])
         self._level = 0
         self._attr_unique_id = entry.entry_id
 
@@ -107,16 +103,18 @@ class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
     async def async_increase_speed(self, percentage_step: int | None = None) -> None:
         """Bump speed up by N hardware levels (no recalibration)."""
         steps = self._steps_from_percentage(percentage_step)
-        plus = NovyCookerHoodCommand(channel=self._code, key=COMMAND_PLUS)
-        await self._async_send_repeated(plus, steps)
+        plus = await self._codes.async_load_command(COMMAND_PLUS)
+        for _ in range(steps):
+            await self._async_send(plus)
         self._level = min(SPEED_COUNT, self._level + steps)
         self.async_write_ha_state()
 
     async def async_decrease_speed(self, percentage_step: int | None = None) -> None:
         """Bump speed down by N hardware levels (no recalibration)."""
         steps = self._steps_from_percentage(percentage_step)
-        minus = NovyCookerHoodCommand(channel=self._code, key=COMMAND_MINUS)
-        await self._async_send_repeated(minus, steps)
+        minus = await self._codes.async_load_command(COMMAND_MINUS)
+        for _ in range(steps):
+            await self._async_send(minus)
         self._level = max(0, self._level - steps)
         self.async_write_ha_state()
 
@@ -129,25 +127,17 @@ class NovyCookerHoodFan(NovyCookerHoodEntity, FanEntity, RestoreEntity):
 
     async def _async_set_level(self, level: int) -> None:
         """Reset to off with `SPEED_COUNT` minus presses, then climb to level."""
-        minus = NovyCookerHoodCommand(channel=self._code, key=COMMAND_MINUS)
-        await self._async_send_repeated(minus, SPEED_COUNT)
+        minus = await self._codes.async_load_command(COMMAND_MINUS)
+        for _ in range(SPEED_COUNT):
+            await self._async_send(minus)
         if level > 0:
-            await asyncio.sleep(_COMMAND_DELAY)
-            plus = NovyCookerHoodCommand(channel=self._code, key=COMMAND_PLUS)
-            await self._async_send_repeated(plus, level)
+            plus = await self._codes.async_load_command(COMMAND_PLUS)
+            for _ in range(level):
+                await self._async_send(plus)
         self._level = level
         self.async_write_ha_state()
 
-    async def _async_send_repeated(
-        self, command: NovyCookerHoodCommand, count: int
-    ) -> None:
-        """Send the same RF command N times, pausing between presses."""
-        for i in range(count):
-            if i > 0:
-                await asyncio.sleep(_COMMAND_DELAY)
-            await self._async_send(command)
-
-    async def _async_send(self, command: NovyCookerHoodCommand) -> None:
+    async def _async_send(self, command: Any) -> None:
         """Send a single RF command via the configured transmitter."""
         await async_send_command(
             self.hass, self._transmitter, command, context=self._context

homeassistant/components/novy_cooker_hood/light.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 
-from rf_protocols.commands.novy import NovyCookerHoodCommand
+from rf_protocols.codes.novy.cooker_hood import get_codes_for_code
 
 from homeassistant.components.light import ColorMode, LightEntity
 from homeassistant.components.radio_frequency import async_send_command
@@ -37,7 +37,7 @@ class NovyCookerHoodLight(NovyCookerHoodEntity, LightEntity, RestoreEntity):
     def __init__(self, entry: ConfigEntry) -> None:
         """Initialize the light."""
         super().__init__(entry)
-        self._code = entry.data[CONF_CODE]
+        self._codes = get_codes_for_code(entry.data[CONF_CODE])
         self._attr_unique_id = entry.entry_id
 
     async def async_added_to_hass(self) -> None:
@@ -58,9 +58,9 @@ class NovyCookerHoodLight(NovyCookerHoodEntity, LightEntity, RestoreEntity):
         self._attr_is_on = False
         self.async_write_ha_state()
 
-    async def _async_send_command(self, key: str) -> None:
-        """Build the named command and send it via the configured transmitter."""
-        command = NovyCookerHoodCommand(channel=self._code, key=key)
+    async def _async_send_command(self, name: str) -> None:
+        """Load the named command and send it via the configured transmitter."""
+        command = await self._codes.async_load_command(name)
         await async_send_command(
             self.hass, self._transmitter, command, context=self._context
         )

homeassistant/components/numato/__init__.py

@@ -8,6 +8,7 @@ import voluptuous as vol
 
 from homeassistant.const import (
     CONF_BINARY_SENSORS,
+    CONF_DEVICES,
     CONF_ID,
     CONF_NAME,
     CONF_SENSORS,
@@ -28,8 +29,6 @@ DOMAIN = "numato"
 
 CONF_INVERT_LOGIC = "invert_logic"
 CONF_DISCOVER = "discover"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_DEVICES = "devices"
 CONF_DEVICE_ID = "id"
 CONF_PORTS = "ports"
 CONF_SRC_RANGE = "source_range"

homeassistant/components/numato/binary_sensor.py

@@ -6,7 +6,7 @@ import logging
 from numato_gpio import NumatoGpioError
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
-from homeassistant.const import DEVICE_DEFAULT_NAME
+from homeassistant.const import CONF_DEVICES, DEVICE_DEFAULT_NAME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect, dispatcher_send
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -14,7 +14,6 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import (
     CONF_BINARY_SENSORS,
-    CONF_DEVICES,
     CONF_ID,
     CONF_INVERT_LOGIC,
     CONF_PORTS,

homeassistant/components/numato/sensor.py

@@ -5,13 +5,12 @@ import logging
 from numato_gpio import NumatoGpioError
 
 from homeassistant.components.sensor import SensorEntity
-from homeassistant.const import CONF_ID, CONF_NAME, CONF_SENSORS
+from homeassistant.const import CONF_DEVICES, CONF_ID, CONF_NAME, CONF_SENSORS
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from . import (
-    CONF_DEVICES,
     CONF_DST_RANGE,
     CONF_DST_UNIT,
     CONF_PORTS,

homeassistant/components/ollama/__init__.py

@@ -8,7 +8,13 @@ import httpx
 import ollama
 
 from homeassistant.config_entries import ConfigEntry, ConfigSubentry
-from homeassistant.const import CONF_API_KEY, CONF_URL, Platform
+from homeassistant.const import (
+    CONF_API_KEY,
+    CONF_MODEL,
+    CONF_PROMPT,
+    CONF_URL,
+    Platform,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import (
     ConfigEntryAuthFailed,
@@ -26,9 +32,7 @@ from homeassistant.util.ssl import get_default_context
 from .const import (
     CONF_KEEP_ALIVE,
     CONF_MAX_HISTORY,
-    CONF_MODEL,
     CONF_NUM_CTX,
-    CONF_PROMPT,
     CONF_THINK,
     DEFAULT_AI_TASK_NAME,
     DEFAULT_NAME,

homeassistant/components/ollama/config_flow.py

@@ -18,7 +18,14 @@ from homeassistant.config_entries import (
     ConfigSubentryFlow,
     SubentryFlowResult,
 )
-from homeassistant.const import CONF_API_KEY, CONF_LLM_HASS_API, CONF_NAME, CONF_URL
+from homeassistant.const import (
+    CONF_API_KEY,
+    CONF_LLM_HASS_API,
+    CONF_MODEL,
+    CONF_NAME,
+    CONF_PROMPT,
+    CONF_URL,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv, llm
 from homeassistant.helpers.selector import (
@@ -40,9 +47,7 @@ from . import OllamaConfigEntry
 from .const import (
     CONF_KEEP_ALIVE,
     CONF_MAX_HISTORY,
-    CONF_MODEL,
     CONF_NUM_CTX,
-    CONF_PROMPT,
     CONF_THINK,
     DEFAULT_AI_TASK_NAME,
     DEFAULT_CONVERSATION_NAME,

homeassistant/components/ollama/const.py

@@ -4,10 +4,6 @@ DOMAIN = "ollama"
 
 DEFAULT_NAME = "Ollama"
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_MODEL = "model"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_PROMPT = "prompt"
 CONF_THINK = "think"
 
 CONF_KEEP_ALIVE = "keep_alive"

homeassistant/components/ollama/conversation.py

@@ -4,12 +4,12 @@ from typing import Literal
 
 from homeassistant.components import conversation
 from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import CONF_LLM_HASS_API, MATCH_ALL
+from homeassistant.const import CONF_LLM_HASS_API, CONF_PROMPT, MATCH_ALL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import OllamaConfigEntry
-from .const import CONF_PROMPT, DOMAIN
+from .const import DOMAIN
 from .entity import OllamaBaseLLMEntity
 
 

homeassistant/components/ollama/entity.py

@@ -11,6 +11,7 @@ from voluptuous_openapi import convert
 
 from homeassistant.components import conversation
 from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import CONF_MODEL
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, llm
 from homeassistant.helpers.entity import Entity
@@ -20,7 +21,6 @@ from . import OllamaConfigEntry
 from .const import (
     CONF_KEEP_ALIVE,
     CONF_MAX_HISTORY,
-    CONF_MODEL,
     CONF_NUM_CTX,
     CONF_THINK,
     DEFAULT_KEEP_ALIVE,

homeassistant/components/onkyo/config_flow.py

@@ -14,7 +14,7 @@ from homeassistant.config_entries import (
     ConfigFlowResult,
     OptionsFlowWithReload,
 )
-from homeassistant.const import CONF_HOST
+from homeassistant.const import CONF_DEVICE, CONF_HOST
 from homeassistant.core import callback
 from homeassistant.data_entry_flow import section
 from homeassistant.helpers.selector import (
@@ -47,9 +47,6 @@ from .util import get_meaning
 
 _LOGGER = logging.getLogger(__name__)
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_DEVICE = "device"
-
 INPUT_SOURCES_DEFAULT: list[InputSource] = []
 LISTENING_MODES_DEFAULT: list[ListeningMode] = []
 INPUT_SOURCES_ALL_MEANINGS = {

homeassistant/components/openerz/sensor.py

@@ -9,6 +9,7 @@ from homeassistant.components.sensor import (
     PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
     SensorEntity,
 )
+from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -18,8 +19,6 @@ SCAN_INTERVAL = timedelta(hours=12)
 
 CONF_ZIP = "zip"
 CONF_WASTE_TYPE = "waste_type"
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_NAME = "name"
 
 PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
     {

homeassistant/components/openhome/config_flow.py

@@ -37,11 +37,15 @@ class OpenhomeConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.debug("async_step_ssdp: Incomplete discovery, ignoring")
             return self.async_abort(reason="incomplete_discovery")
 
-        _LOGGER.debug(
-            "async_step_ssdp: setting unique id %s", discovery_info.upnp[ATTR_UPNP_UDN]
-        )
+        udn = discovery_info.upnp[ATTR_UPNP_UDN]
+        if isinstance(udn, list):
+            if not udn:
+                return self.async_abort(reason="incomplete_discovery")
+            udn = udn[0]
 
-        await self.async_set_unique_id(discovery_info.upnp[ATTR_UPNP_UDN])
+        _LOGGER.debug("async_step_ssdp: setting unique id %s", udn)
+
+        await self.async_set_unique_id(udn)
         self._abort_if_unique_id_configured({CONF_HOST: discovery_info.ssdp_location})
 
         _LOGGER.debug(

homeassistant/components/openrgb/strings.json

@@ -73,6 +73,9 @@
     }
   },
   "exceptions": {
+    "cannot_connect": {
+      "message": "Failed to connect to OpenRGB SDK server {server_address}: {error}"
+    },
     "communication_error": {
       "message": "Failed to communicate with OpenRGB SDK server {server_address}: {error}"
     },

homeassistant/components/osoenergy/water_heater.py

@@ -15,7 +15,7 @@ from homeassistant.components.water_heater import (
     WaterHeaterEntity,
     WaterHeaterEntityFeature,
 )
-from homeassistant.const import UnitOfTemperature
+from homeassistant.const import SERVICE_TURN_OFF, SERVICE_TURN_ON, UnitOfTemperature
 from homeassistant.core import HomeAssistant, ServiceResponse, SupportsResponse
 from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -45,10 +45,6 @@ SERVICE_GET_PROFILE = "get_profile"
 SERVICE_SET_PROFILE = "set_profile"
 SERVICE_SET_V40MIN = "set_v40_min"
 SERVICE_TURN_AWAY_MODE_ON = "turn_away_mode_on"
-# pylint: disable-next=home-assistant-duplicate-const
-SERVICE_TURN_OFF = "turn_off"
-# pylint: disable-next=home-assistant-duplicate-const
-SERVICE_TURN_ON = "turn_on"
 
 
 async def async_setup_entry(

homeassistant/components/overkiz/cover.py

@@ -429,6 +429,9 @@ COVER_DESCRIPTIONS: list[OverkizCoverDescription] = [
         close_command=OverkizCommand.CLOSE,
         stop_command=OverkizCommand.STOP,
         is_closed_state=OverkizState.CORE_OPEN_CLOSED,
+        current_tilt_position_state=OverkizState.CORE_SLATE_ORIENTATION,
+        set_tilt_position_command=OverkizCommand.SET_ORIENTATION,
+        stop_tilt_command=OverkizCommand.STOP,
     ),
     OverkizCoverDescription(
         key=UIClass.ROLLER_SHUTTER,

homeassistant/components/profiler/__init__.py

@@ -19,7 +19,7 @@ import voluptuous as vol
 
 from homeassistant.components import persistent_notification
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_SCAN_INTERVAL, CONF_TYPE
+from homeassistant.const import CONF_ENABLED, CONF_SCAN_INTERVAL, CONF_TYPE
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
@@ -70,8 +70,6 @@ DEFAULT_SCAN_INTERVAL = timedelta(seconds=30)
 
 DEFAULT_MAX_OBJECTS = 5
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_ENABLED = "enabled"
 CONF_SECONDS = "seconds"
 CONF_MAX_OBJECTS = "max_objects"
 

homeassistant/components/rainmachine/__init__.py

@@ -13,6 +13,7 @@ import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
+    CONF_CONDITION,
     CONF_DEVICE_ID,
     CONF_IP_ADDRESS,
     CONF_PASSWORD,
@@ -67,8 +68,6 @@ PLATFORMS = [
     Platform.UPDATE,
 ]
 
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_CONDITION = "condition"
 CONF_DEWPOINT = "dewpoint"
 CONF_ET = "et"
 CONF_MAXRH = "maxrh"

homeassistant/components/reolink/manifest.json

@@ -20,5 +20,5 @@
   "iot_class": "local_push",
   "loggers": ["reolink_aio"],
   "quality_scale": "platinum",
-  "requirements": ["reolink-aio==0.19.1"]
+  "requirements": ["reolink-aio==0.20.0"]
 }

homeassistant/components/sandbox/__init__.py

@@ -0,0 +1,243 @@
+"""The Sandbox integration.
+
+Manages config entries that should run in isolated sandbox processes.
+Config entries with options["sandbox"] set to a string value are grouped
+by that value — entries sharing the same string run in the same sandbox
+process. The sandbox integration spawns one process per group and provides
+a websocket API for sandbox clients to register entities and push state.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from dataclasses import dataclass, field
+import logging
+import sys
+from typing import Any
+
+from homeassistant.auth.models import RefreshToken, User
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.typing import ConfigType
+
+from .const import DATA_SANDBOX, DOMAIN
+from .entity import SandboxEntityManager
+from . import websocket_api as sandbox_ws
+
+_LOGGER = logging.getLogger(__name__)
+
+type SandboxConfigEntry = ConfigEntry[SandboxEntryData]
+
+
+@dataclass
+class SandboxInstance:
+    """A sandbox instance that runs one or more config entries."""
+
+    sandbox_id: str
+    entries: list[dict[str, Any]]
+    user: User | None = None
+    refresh_token: RefreshToken | None = None
+    access_token: str | None = None
+    process: asyncio.subprocess.Process | None = None
+    managed_entity_ids: set[str] = field(default_factory=set)
+    send_command: Callable[[dict[str, Any]], None] | None = None
+    pending_service_calls: dict[str, asyncio.Future[Any]] = field(
+        default_factory=dict
+    )
+    pending_contexts: dict[str, dict[str, str | None]] = field(
+        default_factory=dict
+    )
+
+
+@dataclass
+class SandboxEntryData:
+    """Runtime data for a sandbox config entry."""
+
+    instance: SandboxInstance | None = None
+
+
+@dataclass
+class SandboxData:
+    """Global sandbox data stored in hass.data."""
+
+    sandboxes: dict[str, SandboxInstance] = field(default_factory=dict)
+    token_to_sandbox: dict[str, str] = field(default_factory=dict)
+    host_entry_ids: dict[str, str] = field(default_factory=dict)
+    entity_managers: dict[str, SandboxEntityManager] = field(default_factory=dict)
+
+    def get_host_entry_id(self, sandbox_id: str) -> str | None:
+        """Return the HA Core config entry ID that hosts this sandbox."""
+        return self.host_entry_ids.get(sandbox_id)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Sandbox integration."""
+    hass.data[DATA_SANDBOX] = SandboxData()
+    sandbox_ws.async_setup(hass)
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: SandboxConfigEntry) -> bool:
+    """Set up a sandbox from a config entry.
+
+    Supports two modes:
+    1. Explicit entries: entry.data["entries"] contains a list of entry configs
+       (used by test infrastructure).
+    2. Discovery: entry.data["group"] names a sandbox group. All config entries
+       with options["sandbox"] == group are collected automatically.
+    """
+    sandbox_data = hass.data[DATA_SANDBOX]
+
+    group = entry.data.get("group")
+    if group:
+        sandbox_entries = _discover_group_entries(hass, group)
+    else:
+        sandbox_entries = entry.data.get("entries", [])
+
+    if not sandbox_entries:
+        _LOGGER.warning("Sandbox %s has no entries to run", entry.entry_id)
+        return True
+
+    sandbox_id = entry.entry_id
+
+    instance = SandboxInstance(
+        sandbox_id=sandbox_id,
+        entries=sandbox_entries,
+    )
+
+    user = await hass.auth.async_create_system_user(
+        f"Sandbox {sandbox_id[:8]}",
+        group_ids=["system-admin"],
+    )
+    refresh_token = await hass.auth.async_create_refresh_token(user)
+    access_token = hass.auth.async_create_access_token(refresh_token)
+
+    instance.user = user
+    instance.refresh_token = refresh_token
+    instance.access_token = access_token
+
+    sandbox_data.sandboxes[sandbox_id] = instance
+    sandbox_data.token_to_sandbox[refresh_token.id] = sandbox_id
+    sandbox_data.host_entry_ids[sandbox_id] = entry.entry_id
+
+    manager = SandboxEntityManager(hass, sandbox_id)
+    sandbox_data.entity_managers[sandbox_id] = manager
+
+    entry.runtime_data = SandboxEntryData(instance=instance)
+
+    ws_url = _get_websocket_url(hass)
+    if ws_url:
+        instance.process = await _spawn_sandbox(
+            hass, ws_url, access_token, sandbox_id
+        )
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: SandboxConfigEntry) -> bool:
+    """Unload a sandbox config entry."""
+    sandbox_data = hass.data[DATA_SANDBOX]
+    sandbox_id = entry.entry_id
+    instance = sandbox_data.sandboxes.pop(sandbox_id, None)
+
+    if instance is None:
+        return True
+
+    if instance.process is not None:
+        try:
+            instance.process.terminate()
+            await asyncio.wait_for(instance.process.wait(), timeout=10)
+        except (ProcessLookupError, asyncio.TimeoutError):
+            if instance.process.returncode is None:
+                instance.process.kill()
+
+    if instance.refresh_token is not None:
+        sandbox_data.token_to_sandbox.pop(instance.refresh_token.id, None)
+        hass.auth.async_remove_refresh_token(instance.refresh_token)
+
+    if instance.user is not None:
+        await hass.auth.async_remove_user(instance.user)
+
+    sandbox_data.host_entry_ids.pop(sandbox_id, None)
+    sandbox_data.entity_managers.pop(sandbox_id, None)
+
+    return True
+
+
+def _discover_group_entries(
+    hass: HomeAssistant, group: str
+) -> list[dict[str, Any]]:
+    """Find all config entries whose options.sandbox matches the group string."""
+    entries = []
+    for entry in hass.config_entries.async_entries():
+        if entry.domain == DOMAIN:
+            continue
+        sandbox_opt = entry.options.get("sandbox")
+        if sandbox_opt == group:
+            entries.append(
+                {
+                    "entry_id": entry.entry_id,
+                    "domain": entry.domain,
+                    "title": entry.title,
+                    "data": dict(entry.data),
+                    "options": {
+                        k: v
+                        for k, v in entry.options.items()
+                        if k != "sandbox"
+                    },
+                }
+            )
+    return entries
+
+
+@callback
+def _get_websocket_url(hass: HomeAssistant) -> str | None:
+    """Build the local websocket URL."""
+    if not hasattr(hass, "http") or hass.http is None:
+        return None
+    port = hass.http.server_port or 8123
+    return f"ws://127.0.0.1:{port}/api/websocket"
+
+
+async def _spawn_sandbox(
+    hass: HomeAssistant,
+    ws_url: str,
+    access_token: str,
+    sandbox_id: str,
+) -> asyncio.subprocess.Process:
+    """Spawn a sandbox subprocess."""
+    _LOGGER.info("Spawning sandbox process for %s", sandbox_id)
+    process = await asyncio.create_subprocess_exec(
+        sys.executable,
+        "-m",
+        "hass_client.sandbox",
+        "--url",
+        ws_url,
+        "--token",
+        access_token,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+
+    async def _log_stream(
+        stream: asyncio.StreamReader, level: int, prefix: str
+    ) -> None:
+        while True:
+            line = await stream.readline()
+            if not line:
+                break
+            _LOGGER.log(level, "[sandbox %s] %s", prefix, line.decode().rstrip())
+
+    if process.stdout:
+        hass.async_create_background_task(
+            _log_stream(process.stdout, logging.INFO, sandbox_id[:8]),
+            f"sandbox_stdout_{sandbox_id}",
+        )
+    if process.stderr:
+        hass.async_create_background_task(
+            _log_stream(process.stderr, logging.WARNING, sandbox_id[:8]),
+            f"sandbox_stderr_{sandbox_id}",
+        )
+
+    return process

homeassistant/components/sandbox/config_flow.py

@@ -0,0 +1,27 @@
+"""Config flow for the Sandbox integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+
+from .const import DOMAIN
+
+
+class SandboxConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Config flow for Sandbox."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        if user_input is not None:
+            return self.async_create_entry(
+                title="Sandbox",
+                data=user_input,
+            )
+
+        return self.async_show_form(step_id="user")

homeassistant/components/sandbox/const.py

@@ -0,0 +1,7 @@
+"""Constants for the Sandbox integration."""
+
+from homeassistant.util.hass_dict import HassKey
+
+DOMAIN = "sandbox"
+
+DATA_SANDBOX: HassKey["SandboxData"] = HassKey(DOMAIN)

homeassistant/components/sandbox/entity/__init__.py

@@ -0,0 +1,280 @@
+"""Remote entity proxies for sandboxed integrations."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+import logging
+from typing import Any
+
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import Entity
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class SandboxEntityDescription:
+    """Description of a remote entity from a sandbox."""
+
+    domain: str
+    platform: str
+    unique_id: str
+    sandbox_id: str
+    sandbox_entry_id: str
+    device_id: str | None = None
+    original_name: str | None = None
+    original_icon: str | None = None
+    entity_category: str | None = None
+    device_class: str | None = None
+    state_class: str | None = None
+    supported_features: int = 0
+    capabilities: dict[str, Any] = field(default_factory=dict)
+    has_entity_name: bool = False
+
+
+class SandboxEntityManager:
+    """Manages proxy entities for a sandbox connection."""
+
+    def __init__(self, hass: HomeAssistant, sandbox_id: str) -> None:
+        """Initialize the entity manager."""
+        self.hass = hass
+        self.sandbox_id = sandbox_id
+        self._entities: dict[str, SandboxProxyEntity] = {}
+        self._pending_calls: dict[str, asyncio.Future[Any]] = {}
+        self._call_id_counter = 0
+
+    @callback
+    def add_entity(self, description: SandboxEntityDescription) -> SandboxProxyEntity:
+        """Create a proxy entity (not yet tracked by entity_id)."""
+        return _create_proxy_entity(description, self)
+
+    @callback
+    def track_entity(self, entity_id: str, entity: SandboxProxyEntity) -> None:
+        """Track a proxy entity by its assigned entity_id."""
+        self._entities[entity_id] = entity
+
+    @callback
+    def get_entity(self, entity_id: str) -> SandboxProxyEntity | None:
+        """Get a proxy entity by entity_id."""
+        return self._entities.get(entity_id)
+
+    @callback
+    def remove_entity(self, entity_id: str) -> None:
+        """Remove a proxy entity."""
+        self._entities.pop(entity_id, None)
+
+    @callback
+    def update_state(
+        self, entity_id: str, state: str, attributes: dict[str, Any] | None
+    ) -> None:
+        """Update a proxy entity's state from sandbox push."""
+        entity = self._entities.get(entity_id)
+        if entity is None:
+            return
+        entity.sandbox_update_state(state, attributes or {})
+
+    @callback
+    def mark_all_unavailable(self) -> None:
+        """Mark all entities as unavailable (sandbox disconnected)."""
+        for entity in self._entities.values():
+            entity.sandbox_set_available(False)
+
+    @callback
+    def mark_all_available(self) -> None:
+        """Mark all entities as available (sandbox reconnected)."""
+        for entity in self._entities.values():
+            entity.sandbox_set_available(True)
+
+    def next_call_id(self) -> str:
+        """Generate a unique call ID."""
+        self._call_id_counter += 1
+        return f"{self.sandbox_id}_{self._call_id_counter}"
+
+    @callback
+    def resolve_call(self, call_id: str, result: Any, error: str | None) -> None:
+        """Resolve a pending method call from the sandbox."""
+        future = self._pending_calls.pop(call_id, None)
+        if future is None or future.done():
+            return
+        if error:
+            future.set_exception(Exception(error))
+        else:
+            future.set_result(result)
+
+    def create_call_future(self, call_id: str) -> asyncio.Future[Any]:
+        """Create a future for a pending call."""
+        future: asyncio.Future[Any] = self.hass.loop.create_future()
+        self._pending_calls[call_id] = future
+        return future
+
+
+class SandboxProxyEntity(Entity):
+    """Base class for proxy entities that live on the host."""
+
+    _attr_should_poll = False
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy entity."""
+        self._description = description
+        self._manager = manager
+        self._sandbox_available = True
+        self._state_cache: dict[str, Any] = {}
+        self._attr_unique_id = description.unique_id
+        self._attr_has_entity_name = description.has_entity_name
+        if description.original_name:
+            self._attr_name = description.original_name
+        if description.original_icon:
+            self._attr_icon = description.original_icon
+        if description.device_class:
+            self._attr_device_class = description.device_class
+        self._attr_supported_features = description.supported_features
+
+    @property
+    def device_info(self) -> DeviceInfo | None:
+        """Return device info to associate with the correct device."""
+        if self._description.device_id is None:
+            return None
+        device_reg = dr.async_get(self.hass)
+        device = device_reg.async_get(self._description.device_id)
+        if device is None:
+            return None
+        return DeviceInfo(identifiers=device.identifiers)
+
+    async def async_added_to_hass(self) -> None:
+        """Register with entity manager once we have our entity_id."""
+        self._manager.track_entity(self.entity_id, self)
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return self._sandbox_available
+
+    @callback
+    def sandbox_update_state(self, state: str, attributes: dict[str, Any]) -> None:
+        """Update state from sandbox push."""
+        self._state_cache.update(attributes)
+        self._state_cache["state"] = state
+        self.async_write_ha_state()
+
+    @callback
+    def sandbox_set_available(self, available: bool) -> None:
+        """Set availability."""
+        self._sandbox_available = available
+        self.async_write_ha_state()
+
+    async def _forward_method(self, method: str, **kwargs: Any) -> Any:
+        """Forward a method call to the sandbox entity."""
+        from ..const import DATA_SANDBOX
+
+        sandbox_data = self.hass.data[DATA_SANDBOX]
+        sandbox_info = sandbox_data.sandboxes.get(self._manager.sandbox_id)
+        if sandbox_info is None or sandbox_info.send_command is None:
+            raise RuntimeError("Sandbox not connected")
+
+        call_id = self._manager.next_call_id()
+        future = self._manager.create_call_future(call_id)
+
+        sandbox_info.send_command(
+            {
+                "type": "call_method",
+                "call_id": call_id,
+                "entity_id": self.entity_id,
+                "method": method,
+                "kwargs": kwargs,
+            }
+        )
+
+        return await asyncio.wait_for(future, timeout=30)
+
+
+from .alarm_control_panel import SandboxAlarmControlPanelEntity
+from .binary_sensor import SandboxBinarySensorEntity
+from .button import SandboxButtonEntity
+from .calendar import SandboxCalendarEntity
+from .climate import SandboxClimateEntity
+from .cover import SandboxCoverEntity
+from .date import SandboxDateEntity
+from .datetime import SandboxDateTimeEntity
+from .device_tracker import SandboxScannerEntity, SandboxTrackerEntity
+from .event import SandboxEventEntity
+from .fan import SandboxFanEntity
+from .humidifier import SandboxHumidifierEntity
+from .lawn_mower import SandboxLawnMowerEntity
+from .light import SandboxLightEntity
+from .lock import SandboxLockEntity
+from .media_player import SandboxMediaPlayerEntity
+from .notify import SandboxNotifyEntity
+from .number import SandboxNumberEntity
+from .remote import SandboxRemoteEntity
+from .scene import SandboxSceneEntity
+from .select import SandboxSelectEntity
+from .sensor import SandboxSensorEntity
+from .siren import SandboxSirenEntity
+from .switch import SandboxSwitchEntity
+from .text import SandboxTextEntity
+from .time import SandboxTimeEntity
+from .todo import SandboxTodoListEntity
+from .update import SandboxUpdateEntity
+from .vacuum import SandboxVacuumEntity
+from .valve import SandboxValveEntity
+from .water_heater import SandboxWaterHeaterEntity
+from .weather import SandboxWeatherEntity
+
+_DOMAIN_ENTITY_MAP: dict[str, type[SandboxProxyEntity]] = {
+    "alarm_control_panel": SandboxAlarmControlPanelEntity,
+    "binary_sensor": SandboxBinarySensorEntity,
+    "button": SandboxButtonEntity,
+    "calendar": SandboxCalendarEntity,
+    "climate": SandboxClimateEntity,
+    "cover": SandboxCoverEntity,
+    "date": SandboxDateEntity,
+    "datetime": SandboxDateTimeEntity,
+    "device_tracker": SandboxTrackerEntity,
+    "event": SandboxEventEntity,
+    "fan": SandboxFanEntity,
+    "humidifier": SandboxHumidifierEntity,
+    "lawn_mower": SandboxLawnMowerEntity,
+    "light": SandboxLightEntity,
+    "lock": SandboxLockEntity,
+    "media_player": SandboxMediaPlayerEntity,
+    "notify": SandboxNotifyEntity,
+    "number": SandboxNumberEntity,
+    "remote": SandboxRemoteEntity,
+    "scene": SandboxSceneEntity,
+    "select": SandboxSelectEntity,
+    "sensor": SandboxSensorEntity,
+    "siren": SandboxSirenEntity,
+    "switch": SandboxSwitchEntity,
+    "text": SandboxTextEntity,
+    "time": SandboxTimeEntity,
+    "todo": SandboxTodoListEntity,
+    "update": SandboxUpdateEntity,
+    "vacuum": SandboxVacuumEntity,
+    "valve": SandboxValveEntity,
+    "water_heater": SandboxWaterHeaterEntity,
+    "weather": SandboxWeatherEntity,
+}
+
+
+def _create_proxy_entity(
+    description: SandboxEntityDescription,
+    manager: SandboxEntityManager,
+) -> SandboxProxyEntity:
+    """Create the appropriate proxy entity for the domain."""
+    entity_cls = _DOMAIN_ENTITY_MAP.get(description.domain, SandboxProxyEntity)
+    return entity_cls(description, manager)
+
+__all__ = [
+    "SandboxEntityDescription",
+    "SandboxEntityManager",
+    "SandboxProxyEntity",
+    "_DOMAIN_ENTITY_MAP",
+    "_create_proxy_entity",
+]

homeassistant/components/sandbox/entity/alarm_control_panel.py

@@ -0,0 +1,59 @@
+"""Sandbox proxy for alarm_control_panel entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.alarm_control_panel import (
+    AlarmControlPanelEntity,
+    AlarmControlPanelEntityFeature,
+)
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxAlarmControlPanelEntity(SandboxProxyEntity, AlarmControlPanelEntity):
+    """Proxy for an alarm_control_panel entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy alarm control panel entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = AlarmControlPanelEntityFeature(
+            description.supported_features
+        )
+        caps = description.capabilities
+        if code_format := caps.get("code_format"):
+            self._attr_code_format = code_format
+        if (code_arm_required := caps.get("code_arm_required")) is not None:
+            self._attr_code_arm_required = code_arm_required
+
+    @property
+    def alarm_state(self) -> str | None:
+        """Return the alarm state."""
+        return self._state_cache.get("state")
+
+    async def async_alarm_disarm(self, code: str | None = None) -> None:
+        """Forward alarm_disarm to sandbox."""
+        await self._forward_method("async_alarm_disarm", code=code)
+
+    async def async_alarm_arm_home(self, code: str | None = None) -> None:
+        """Forward alarm_arm_home to sandbox."""
+        await self._forward_method("async_alarm_arm_home", code=code)
+
+    async def async_alarm_arm_away(self, code: str | None = None) -> None:
+        """Forward alarm_arm_away to sandbox."""
+        await self._forward_method("async_alarm_arm_away", code=code)
+
+    async def async_alarm_arm_night(self, code: str | None = None) -> None:
+        """Forward alarm_arm_night to sandbox."""
+        await self._forward_method("async_alarm_arm_night", code=code)
+
+    async def async_alarm_arm_vacation(self, code: str | None = None) -> None:
+        """Forward alarm_arm_vacation to sandbox."""
+        await self._forward_method("async_alarm_arm_vacation", code=code)
+
+    async def async_alarm_trigger(self, code: str | None = None) -> None:
+        """Forward alarm_trigger to sandbox."""
+        await self._forward_method("async_alarm_trigger", code=code)

homeassistant/components/sandbox/entity/binary_sensor.py

@@ -0,0 +1,19 @@
+"""Sandbox proxy for binary_sensor entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.binary_sensor import BinarySensorEntity
+
+from . import SandboxProxyEntity
+
+
+class SandboxBinarySensorEntity(SandboxProxyEntity, BinarySensorEntity):
+    """Proxy for a binary_sensor entity in a sandbox."""
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return if the sensor is on."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return state == "on"

homeassistant/components/sandbox/entity/button.py

@@ -0,0 +1,15 @@
+"""Sandbox proxy for button entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.button import ButtonEntity
+
+from . import SandboxProxyEntity
+
+
+class SandboxButtonEntity(SandboxProxyEntity, ButtonEntity):
+    """Proxy for a button entity in a sandbox."""
+
+    async def async_press(self) -> None:
+        """Forward press to sandbox."""
+        await self._forward_method("async_press")

homeassistant/components/sandbox/entity/calendar.py

@@ -0,0 +1,60 @@
+"""Sandbox proxy for calendar entities."""
+
+from __future__ import annotations
+
+from datetime import date, datetime
+
+from homeassistant.components.calendar import CalendarEntity, CalendarEvent
+from homeassistant.core import HomeAssistant
+
+from . import SandboxProxyEntity
+
+
+class SandboxCalendarEntity(SandboxProxyEntity, CalendarEntity):
+    """Proxy for a calendar entity in a sandbox."""
+
+    @property
+    def event(self) -> CalendarEvent | None:
+        """Return the next event."""
+        event_data = self._state_cache.get("event")
+        if event_data is None:
+            return None
+        start = event_data.get("start")
+        end = event_data.get("end")
+        if isinstance(start, str):
+            start = datetime.fromisoformat(start) if "T" in start else date.fromisoformat(start)
+        if isinstance(end, str):
+            end = datetime.fromisoformat(end) if "T" in end else date.fromisoformat(end)
+        return CalendarEvent(
+            start=start,
+            end=end,
+            summary=event_data.get("summary", ""),
+            description=event_data.get("description"),
+            location=event_data.get("location"),
+        )
+
+    async def async_get_events(self, hass: HomeAssistant, start_date, end_date) -> list[CalendarEvent]:
+        """Forward get_events to sandbox."""
+        result = await self._forward_method(
+            "async_get_events",
+            start_date=start_date.isoformat(),
+            end_date=end_date.isoformat(),
+        )
+        if not result:
+            return []
+        events = []
+        for ev in result:
+            start = ev.get("start")
+            end = ev.get("end")
+            if isinstance(start, str):
+                start = datetime.fromisoformat(start) if "T" in start else date.fromisoformat(start)
+            if isinstance(end, str):
+                end = datetime.fromisoformat(end) if "T" in end else date.fromisoformat(end)
+            events.append(CalendarEvent(
+                start=start,
+                end=end,
+                summary=ev.get("summary", ""),
+                description=ev.get("description"),
+                location=ev.get("location"),
+            ))
+        return events

homeassistant/components/sandbox/entity/climate.py

@@ -0,0 +1,135 @@
+"""Sandbox proxy for climate entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.climate import ClimateEntity, ClimateEntityFeature, HVACMode
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxClimateEntity(SandboxProxyEntity, ClimateEntity):
+    """Proxy for a climate entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy climate entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = ClimateEntityFeature(
+            description.supported_features
+        )
+        caps = description.capabilities
+        if hvac_modes := caps.get("hvac_modes"):
+            self._attr_hvac_modes = [HVACMode(m) for m in hvac_modes]
+        if fan_modes := caps.get("fan_modes"):
+            self._attr_fan_modes = fan_modes
+        if preset_modes := caps.get("preset_modes"):
+            self._attr_preset_modes = preset_modes
+        if swing_modes := caps.get("swing_modes"):
+            self._attr_swing_modes = swing_modes
+        if (min_temp := caps.get("min_temp")) is not None:
+            self._attr_min_temp = min_temp
+        if (max_temp := caps.get("max_temp")) is not None:
+            self._attr_max_temp = max_temp
+        if (min_humidity := caps.get("min_humidity")) is not None:
+            self._attr_min_humidity = min_humidity
+        if (max_humidity := caps.get("max_humidity")) is not None:
+            self._attr_max_humidity = max_humidity
+        if (temp_step := caps.get("target_temperature_step")) is not None:
+            self._attr_target_temperature_step = temp_step
+        if temp_unit := caps.get("temperature_unit"):
+            self._attr_temperature_unit = temp_unit
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        mode = self._state_cache.get("hvac_mode")
+        if mode is None:
+            return None
+        return HVACMode(mode)
+
+    @property
+    def hvac_action(self) -> str | None:
+        """Return the current HVAC action."""
+        return self._state_cache.get("hvac_action")
+
+    @property
+    def current_temperature(self) -> float | None:
+        """Return the current temperature."""
+        return self._state_cache.get("current_temperature")
+
+    @property
+    def target_temperature(self) -> float | None:
+        """Return the target temperature."""
+        return self._state_cache.get("target_temperature")
+
+    @property
+    def target_temperature_high(self) -> float | None:
+        """Return the high target temperature."""
+        return self._state_cache.get("target_temperature_high")
+
+    @property
+    def target_temperature_low(self) -> float | None:
+        """Return the low target temperature."""
+        return self._state_cache.get("target_temperature_low")
+
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        return self._state_cache.get("current_humidity")
+
+    @property
+    def target_humidity(self) -> float | None:
+        """Return the target humidity."""
+        return self._state_cache.get("target_humidity")
+
+    @property
+    def fan_mode(self) -> str | None:
+        """Return the current fan mode."""
+        return self._state_cache.get("fan_mode")
+
+    @property
+    def preset_mode(self) -> str | None:
+        """Return the current preset mode."""
+        return self._state_cache.get("preset_mode")
+
+    @property
+    def swing_mode(self) -> str | None:
+        """Return the current swing mode."""
+        return self._state_cache.get("swing_mode")
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Forward set_temperature to sandbox."""
+        await self._forward_method("async_set_temperature", **kwargs)
+
+    async def async_set_humidity(self, humidity: int) -> None:
+        """Forward set_humidity to sandbox."""
+        await self._forward_method("async_set_humidity", humidity=humidity)
+
+    async def async_set_fan_mode(self, fan_mode: str) -> None:
+        """Forward set_fan_mode to sandbox."""
+        await self._forward_method("async_set_fan_mode", fan_mode=fan_mode)
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Forward set_hvac_mode to sandbox."""
+        await self._forward_method("async_set_hvac_mode", hvac_mode=hvac_mode)
+
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
+        """Forward set_preset_mode to sandbox."""
+        await self._forward_method("async_set_preset_mode", preset_mode=preset_mode)
+
+    async def async_set_swing_mode(self, swing_mode: str) -> None:
+        """Forward set_swing_mode to sandbox."""
+        await self._forward_method("async_set_swing_mode", swing_mode=swing_mode)
+
+    async def async_turn_on(self) -> None:
+        """Forward turn_on to sandbox."""
+        await self._forward_method("async_turn_on")
+
+    async def async_turn_off(self) -> None:
+        """Forward turn_off to sandbox."""
+        await self._forward_method("async_turn_off")

homeassistant/components/sandbox/entity/cover.py

@@ -0,0 +1,84 @@
+"""Sandbox proxy for cover entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.cover import CoverEntity, CoverEntityFeature
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxCoverEntity(SandboxProxyEntity, CoverEntity):
+    """Proxy for a cover entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy cover entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = CoverEntityFeature(
+            description.supported_features
+        )
+
+    @property
+    def is_closed(self) -> bool | None:
+        """Return if the cover is closed."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return state == "closed"
+
+    @property
+    def is_opening(self) -> bool | None:
+        """Return if the cover is opening."""
+        return self._state_cache.get("is_opening")
+
+    @property
+    def is_closing(self) -> bool | None:
+        """Return if the cover is closing."""
+        return self._state_cache.get("is_closing")
+
+    @property
+    def current_cover_position(self) -> int | None:
+        """Return the current cover position."""
+        return self._state_cache.get("current_cover_position")
+
+    @property
+    def current_cover_tilt_position(self) -> int | None:
+        """Return the current tilt position."""
+        return self._state_cache.get("current_cover_tilt_position")
+
+    async def async_open_cover(self, **kwargs: Any) -> None:
+        """Forward open_cover to sandbox."""
+        await self._forward_method("async_open_cover", **kwargs)
+
+    async def async_close_cover(self, **kwargs: Any) -> None:
+        """Forward close_cover to sandbox."""
+        await self._forward_method("async_close_cover", **kwargs)
+
+    async def async_stop_cover(self, **kwargs: Any) -> None:
+        """Forward stop_cover to sandbox."""
+        await self._forward_method("async_stop_cover", **kwargs)
+
+    async def async_set_cover_position(self, **kwargs: Any) -> None:
+        """Forward set_cover_position to sandbox."""
+        await self._forward_method("async_set_cover_position", **kwargs)
+
+    async def async_open_cover_tilt(self, **kwargs: Any) -> None:
+        """Forward open_cover_tilt to sandbox."""
+        await self._forward_method("async_open_cover_tilt", **kwargs)
+
+    async def async_close_cover_tilt(self, **kwargs: Any) -> None:
+        """Forward close_cover_tilt to sandbox."""
+        await self._forward_method("async_close_cover_tilt", **kwargs)
+
+    async def async_stop_cover_tilt(self, **kwargs: Any) -> None:
+        """Forward stop_cover_tilt to sandbox."""
+        await self._forward_method("async_stop_cover_tilt", **kwargs)
+
+    async def async_set_cover_tilt_position(self, **kwargs: Any) -> None:
+        """Forward set_cover_tilt_position to sandbox."""
+        await self._forward_method("async_set_cover_tilt_position", **kwargs)

homeassistant/components/sandbox/entity/date.py

@@ -0,0 +1,27 @@
+"""Sandbox proxy for date entities."""
+
+from __future__ import annotations
+
+from datetime import date
+
+from homeassistant.components.date import DateEntity
+
+from . import SandboxProxyEntity
+
+
+class SandboxDateEntity(SandboxProxyEntity, DateEntity):
+    """Proxy for a date entity in a sandbox."""
+
+    @property
+    def native_value(self):
+        """Return the current date value."""
+        val = self._state_cache.get("state")
+        if val is None:
+            return None
+        if isinstance(val, str):
+            return date.fromisoformat(val)
+        return val
+
+    async def async_set_value(self, value) -> None:
+        """Forward set_value to sandbox."""
+        await self._forward_method("async_set_value", value=value.isoformat())

homeassistant/components/sandbox/entity/datetime.py

@@ -0,0 +1,30 @@
+"""Sandbox proxy for datetime entities."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from homeassistant.components.datetime import DateTimeEntity
+
+from . import SandboxProxyEntity
+
+
+class SandboxDateTimeEntity(SandboxProxyEntity, DateTimeEntity):
+    """Proxy for a datetime entity in a sandbox."""
+
+    @property
+    def native_value(self):
+        """Return the current datetime value."""
+        val = self._state_cache.get("state")
+        if val is None:
+            return None
+        if isinstance(val, str):
+            dt = datetime.fromisoformat(val)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=timezone.utc)
+            return dt
+        return val
+
+    async def async_set_value(self, value) -> None:
+        """Forward set_value to sandbox."""
+        await self._forward_method("async_set_value", value=value.isoformat())

homeassistant/components/sandbox/entity/device_tracker.py

@@ -0,0 +1,82 @@
+"""Sandbox proxy for device_tracker entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.device_tracker import SourceType
+from homeassistant.components.device_tracker.config_entry import ScannerEntity, TrackerEntity
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxTrackerEntity(SandboxProxyEntity, TrackerEntity):
+    """Proxy for a GPS device tracker entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy tracker entity."""
+        super().__init__(description, manager)
+        if source_type := description.capabilities.get("source_type"):
+            self._attr_source_type = SourceType(source_type)
+
+    @property
+    def latitude(self) -> float | None:
+        """Return the latitude."""
+        return self._state_cache.get("latitude")
+
+    @property
+    def longitude(self) -> float | None:
+        """Return the longitude."""
+        return self._state_cache.get("longitude")
+
+    @property
+    def location_accuracy(self) -> float:
+        """Return the location accuracy."""
+        return self._state_cache.get("location_accuracy", 0)
+
+    @property
+    def location_name(self) -> str | None:
+        """Return the location name."""
+        return self._state_cache.get("location_name")
+
+    @property
+    def battery_level(self) -> int | None:
+        """Return the battery level."""
+        return self._state_cache.get("battery_level")
+
+
+class SandboxScannerEntity(SandboxProxyEntity, ScannerEntity):
+    """Proxy for a scanner device tracker entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy scanner entity."""
+        super().__init__(description, manager)
+        if source_type := description.capabilities.get("source_type"):
+            self._attr_source_type = SourceType(source_type)
+
+    @property
+    def is_connected(self) -> bool:
+        """Return if the device is connected."""
+        state = self._state_cache.get("state")
+        return state == "home"
+
+    @property
+    def ip_address(self) -> str | None:
+        """Return the IP address."""
+        return self._state_cache.get("ip_address")
+
+    @property
+    def mac_address(self) -> str | None:
+        """Return the MAC address."""
+        return self._state_cache.get("mac_address")
+
+    @property
+    def hostname(self) -> str | None:
+        """Return the hostname."""
+        return self._state_cache.get("hostname")

homeassistant/components/sandbox/entity/event.py

@@ -0,0 +1,40 @@
+"""Sandbox proxy for event entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.event import EventEntity
+from homeassistant.core import callback
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxEventEntity(SandboxProxyEntity, EventEntity):
+    """Proxy for an event entity in a sandbox."""
+
+    _unrecorded_attributes = frozenset({})
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy event entity."""
+        super().__init__(description, manager)
+        self._attr_event_types = description.capabilities.get("event_types", [])
+
+    @callback
+    def sandbox_update_state(self, state: str, attributes: dict[str, Any]) -> None:
+        """Handle event firing from sandbox."""
+        event_type = attributes.get("event_type")
+        if event_type:
+            event_attributes = {
+                k: v
+                for k, v in attributes.items()
+                if k not in ("event_type", "state")
+            }
+            self._trigger_event(event_type, event_attributes or None)
+            self.async_write_ha_state()
+        else:
+            super().sandbox_update_state(state, attributes)

homeassistant/components/sandbox/entity/fan.py

@@ -0,0 +1,80 @@
+"""Sandbox proxy for fan entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.fan import FanEntity, FanEntityFeature
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxFanEntity(SandboxProxyEntity, FanEntity):
+    """Proxy for a fan entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy fan entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = FanEntityFeature(
+            description.supported_features
+        )
+        if preset_modes := description.capabilities.get("preset_modes"):
+            self._attr_preset_modes = preset_modes
+        if speed_count := description.capabilities.get("speed_count"):
+            self._attr_speed_count = speed_count
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return if the fan is on."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return state == "on"
+
+    @property
+    def percentage(self) -> int | None:
+        """Return the current speed percentage."""
+        return self._state_cache.get("percentage")
+
+    @property
+    def preset_mode(self) -> str | None:
+        """Return the current preset mode."""
+        return self._state_cache.get("preset_mode")
+
+    @property
+    def current_direction(self) -> str | None:
+        """Return the current direction."""
+        return self._state_cache.get("current_direction")
+
+    @property
+    def oscillating(self) -> bool | None:
+        """Return if the fan is oscillating."""
+        return self._state_cache.get("oscillating")
+
+    async def async_turn_on(self, percentage: int | None = None, preset_mode: str | None = None, **kwargs: Any) -> None:
+        """Forward turn_on to sandbox."""
+        await self._forward_method("async_turn_on", percentage=percentage, preset_mode=preset_mode, **kwargs)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Forward turn_off to sandbox."""
+        await self._forward_method("async_turn_off", **kwargs)
+
+    async def async_set_percentage(self, percentage: int) -> None:
+        """Forward set_percentage to sandbox."""
+        await self._forward_method("async_set_percentage", percentage=percentage)
+
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
+        """Forward set_preset_mode to sandbox."""
+        await self._forward_method("async_set_preset_mode", preset_mode=preset_mode)
+
+    async def async_set_direction(self, direction: str) -> None:
+        """Forward set_direction to sandbox."""
+        await self._forward_method("async_set_direction", direction=direction)
+
+    async def async_oscillate(self, oscillating: bool) -> None:
+        """Forward oscillate to sandbox."""
+        await self._forward_method("async_oscillate", oscillating=oscillating)

homeassistant/components/sandbox/entity/humidifier.py

@@ -0,0 +1,75 @@
+"""Sandbox proxy for humidifier entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.humidifier import HumidifierEntity, HumidifierEntityFeature
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxHumidifierEntity(SandboxProxyEntity, HumidifierEntity):
+    """Proxy for a humidifier entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy humidifier entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = HumidifierEntityFeature(
+            description.supported_features
+        )
+        caps = description.capabilities
+        if available_modes := caps.get("available_modes"):
+            self._attr_available_modes = available_modes
+        if (min_humidity := caps.get("min_humidity")) is not None:
+            self._attr_min_humidity = min_humidity
+        if (max_humidity := caps.get("max_humidity")) is not None:
+            self._attr_max_humidity = max_humidity
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return if the humidifier is on."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return state == "on"
+
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        return self._state_cache.get("current_humidity")
+
+    @property
+    def target_humidity(self) -> float | None:
+        """Return the target humidity."""
+        return self._state_cache.get("target_humidity")
+
+    @property
+    def mode(self) -> str | None:
+        """Return the current mode."""
+        return self._state_cache.get("mode")
+
+    @property
+    def action(self) -> str | None:
+        """Return the current action."""
+        return self._state_cache.get("action")
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Forward turn_on to sandbox."""
+        await self._forward_method("async_turn_on", **kwargs)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Forward turn_off to sandbox."""
+        await self._forward_method("async_turn_off", **kwargs)
+
+    async def async_set_humidity(self, humidity: int) -> None:
+        """Forward set_humidity to sandbox."""
+        await self._forward_method("async_set_humidity", humidity=humidity)
+
+    async def async_set_mode(self, mode: str) -> None:
+        """Forward set_mode to sandbox."""
+        await self._forward_method("async_set_mode", mode=mode)

homeassistant/components/sandbox/entity/lawn_mower.py

@@ -0,0 +1,42 @@
+"""Sandbox proxy for lawn_mower entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.lawn_mower import LawnMowerActivity, LawnMowerEntity, LawnMowerEntityFeature
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxLawnMowerEntity(SandboxProxyEntity, LawnMowerEntity):
+    """Proxy for a lawn_mower entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy lawn mower entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = LawnMowerEntityFeature(
+            description.supported_features
+        )
+
+    @property
+    def activity(self) -> LawnMowerActivity | None:
+        """Return the current activity."""
+        val = self._state_cache.get("activity")
+        if val is None:
+            return None
+        return LawnMowerActivity(val)
+
+    async def async_start_mowing(self) -> None:
+        """Forward start_mowing to sandbox."""
+        await self._forward_method("async_start_mowing")
+
+    async def async_dock(self) -> None:
+        """Forward dock to sandbox."""
+        await self._forward_method("async_dock")
+
+    async def async_pause(self) -> None:
+        """Forward pause to sandbox."""
+        await self._forward_method("async_pause")

homeassistant/components/sandbox/entity/light.py

@@ -0,0 +1,134 @@
+"""Sandbox proxy for light entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.light import (
+    ATTR_BRIGHTNESS,
+    ATTR_COLOR_MODE,
+    ATTR_COLOR_TEMP_KELVIN,
+    ATTR_EFFECT,
+    ATTR_EFFECT_LIST,
+    ATTR_HS_COLOR,
+    ATTR_MAX_COLOR_TEMP_KELVIN,
+    ATTR_MIN_COLOR_TEMP_KELVIN,
+    ATTR_RGB_COLOR,
+    ATTR_RGBW_COLOR,
+    ATTR_RGBWW_COLOR,
+    ATTR_SUPPORTED_COLOR_MODES,
+    ATTR_XY_COLOR,
+    ColorMode,
+    LightEntity,
+    LightEntityFeature,
+)
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxLightEntity(SandboxProxyEntity, LightEntity):
+    """Proxy for a light entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy light entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = LightEntityFeature(
+            description.supported_features
+        )
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return if the light is on."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return state == "on"
+
+    @property
+    def brightness(self) -> int | None:
+        """Return the brightness."""
+        return self._state_cache.get(ATTR_BRIGHTNESS)
+
+    @property
+    def color_mode(self) -> ColorMode | str | None:
+        """Return the color mode."""
+        return self._state_cache.get(ATTR_COLOR_MODE)
+
+    @property
+    def hs_color(self) -> tuple[float, float] | None:
+        """Return the HS color."""
+        val = self._state_cache.get(ATTR_HS_COLOR)
+        return tuple(val) if val else None
+
+    @property
+    def rgb_color(self) -> tuple[int, int, int] | None:
+        """Return the RGB color."""
+        val = self._state_cache.get(ATTR_RGB_COLOR)
+        return tuple(val) if val else None
+
+    @property
+    def rgbw_color(self) -> tuple[int, int, int, int] | None:
+        """Return the RGBW color."""
+        val = self._state_cache.get(ATTR_RGBW_COLOR)
+        return tuple(val) if val else None
+
+    @property
+    def rgbww_color(self) -> tuple[int, int, int, int, int] | None:
+        """Return the RGBWW color."""
+        val = self._state_cache.get(ATTR_RGBWW_COLOR)
+        return tuple(val) if val else None
+
+    @property
+    def xy_color(self) -> tuple[float, float] | None:
+        """Return the XY color."""
+        val = self._state_cache.get(ATTR_XY_COLOR)
+        return tuple(val) if val else None
+
+    @property
+    def color_temp_kelvin(self) -> int | None:
+        """Return the color temperature in kelvin."""
+        return self._state_cache.get(ATTR_COLOR_TEMP_KELVIN)
+
+    @property
+    def min_color_temp_kelvin(self) -> int:
+        """Return the min color temperature."""
+        return self._description.capabilities.get(
+            ATTR_MIN_COLOR_TEMP_KELVIN, 2000
+        )
+
+    @property
+    def max_color_temp_kelvin(self) -> int:
+        """Return the max color temperature."""
+        return self._description.capabilities.get(
+            ATTR_MAX_COLOR_TEMP_KELVIN, 6500
+        )
+
+    @property
+    def effect(self) -> str | None:
+        """Return the current effect."""
+        return self._state_cache.get(ATTR_EFFECT)
+
+    @property
+    def effect_list(self) -> list[str] | None:
+        """Return the list of supported effects."""
+        return self._description.capabilities.get(ATTR_EFFECT_LIST)
+
+    @property
+    def supported_color_modes(self) -> set[ColorMode] | set[str] | None:
+        """Return the supported color modes."""
+        modes = self._description.capabilities.get(ATTR_SUPPORTED_COLOR_MODES)
+        if modes is None:
+            return None
+        return {ColorMode(m) for m in modes}
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Forward turn_on to sandbox."""
+        await self._forward_method("async_turn_on", **kwargs)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Forward turn_off to sandbox."""
+        await self._forward_method("async_turn_off", **kwargs)

homeassistant/components/sandbox/entity/lock.py

@@ -0,0 +1,64 @@
+"""Sandbox proxy for lock entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.lock import LockEntity, LockEntityFeature
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxLockEntity(SandboxProxyEntity, LockEntity):
+    """Proxy for a lock entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy lock entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = LockEntityFeature(
+            description.supported_features
+        )
+
+    @property
+    def is_locked(self) -> bool | None:
+        """Return if the lock is locked."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return state == "locked"
+
+    @property
+    def is_locking(self) -> bool | None:
+        """Return if the lock is locking."""
+        return self._state_cache.get("is_locking")
+
+    @property
+    def is_unlocking(self) -> bool | None:
+        """Return if the lock is unlocking."""
+        return self._state_cache.get("is_unlocking")
+
+    @property
+    def is_jammed(self) -> bool | None:
+        """Return if the lock is jammed."""
+        return self._state_cache.get("is_jammed")
+
+    @property
+    def is_open(self) -> bool | None:
+        """Return if the lock is open."""
+        return self._state_cache.get("is_open")
+
+    async def async_lock(self, **kwargs: Any) -> None:
+        """Forward lock to sandbox."""
+        await self._forward_method("async_lock", **kwargs)
+
+    async def async_unlock(self, **kwargs: Any) -> None:
+        """Forward unlock to sandbox."""
+        await self._forward_method("async_unlock", **kwargs)
+
+    async def async_open(self, **kwargs: Any) -> None:
+        """Forward open to sandbox."""
+        await self._forward_method("async_open", **kwargs)

homeassistant/components/sandbox/entity/media_player.py

@@ -0,0 +1,170 @@
+"""Sandbox proxy for media_player entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.media_player import (
+    MediaPlayerEntity,
+    MediaPlayerEntityFeature,
+    MediaPlayerState,
+    RepeatMode,
+)
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxMediaPlayerEntity(SandboxProxyEntity, MediaPlayerEntity):
+    """Proxy for a media_player entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy media player entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = MediaPlayerEntityFeature(
+            description.supported_features
+        )
+        caps = description.capabilities
+        if source_list := caps.get("source_list"):
+            self._attr_source_list = source_list
+        if sound_mode_list := caps.get("sound_mode_list"):
+            self._attr_sound_mode_list = sound_mode_list
+
+    @property
+    def state(self) -> MediaPlayerState | None:
+        """Return the current state."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return MediaPlayerState(state)
+
+    @property
+    def volume_level(self) -> float | None:
+        """Return the volume level."""
+        return self._state_cache.get("volume_level")
+
+    @property
+    def is_volume_muted(self) -> bool | None:
+        """Return if volume is muted."""
+        return self._state_cache.get("is_volume_muted")
+
+    @property
+    def media_content_id(self) -> str | None:
+        """Return the media content ID."""
+        return self._state_cache.get("media_content_id")
+
+    @property
+    def media_content_type(self) -> str | None:
+        """Return the media content type."""
+        return self._state_cache.get("media_content_type")
+
+    @property
+    def media_title(self) -> str | None:
+        """Return the media title."""
+        return self._state_cache.get("media_title")
+
+    @property
+    def media_artist(self) -> str | None:
+        """Return the media artist."""
+        return self._state_cache.get("media_artist")
+
+    @property
+    def media_album_name(self) -> str | None:
+        """Return the media album name."""
+        return self._state_cache.get("media_album_name")
+
+    @property
+    def media_duration(self) -> float | None:
+        """Return the media duration."""
+        return self._state_cache.get("media_duration")
+
+    @property
+    def media_position(self) -> float | None:
+        """Return the media position."""
+        return self._state_cache.get("media_position")
+
+    @property
+    def source(self) -> str | None:
+        """Return the current source."""
+        return self._state_cache.get("source")
+
+    @property
+    def sound_mode(self) -> str | None:
+        """Return the current sound mode."""
+        return self._state_cache.get("sound_mode")
+
+    @property
+    def shuffle(self) -> bool | None:
+        """Return if shuffle is enabled."""
+        return self._state_cache.get("shuffle")
+
+    @property
+    def repeat(self) -> RepeatMode | None:
+        """Return the current repeat mode."""
+        val = self._state_cache.get("repeat")
+        if val is None:
+            return None
+        return RepeatMode(val)
+
+    async def async_turn_on(self) -> None:
+        """Forward turn_on to sandbox."""
+        await self._forward_method("async_turn_on")
+
+    async def async_turn_off(self) -> None:
+        """Forward turn_off to sandbox."""
+        await self._forward_method("async_turn_off")
+
+    async def async_volume_up(self) -> None:
+        """Forward volume_up to sandbox."""
+        await self._forward_method("async_volume_up")
+
+    async def async_volume_down(self) -> None:
+        """Forward volume_down to sandbox."""
+        await self._forward_method("async_volume_down")
+
+    async def async_set_volume_level(self, volume: float) -> None:
+        """Forward set_volume_level to sandbox."""
+        await self._forward_method("async_set_volume_level", volume=volume)
+
+    async def async_mute_volume(self, mute: bool) -> None:
+        """Forward mute_volume to sandbox."""
+        await self._forward_method("async_mute_volume", mute=mute)
+
+    async def async_media_play(self) -> None:
+        """Forward media_play to sandbox."""
+        await self._forward_method("async_media_play")
+
+    async def async_media_pause(self) -> None:
+        """Forward media_pause to sandbox."""
+        await self._forward_method("async_media_pause")
+
+    async def async_media_stop(self) -> None:
+        """Forward media_stop to sandbox."""
+        await self._forward_method("async_media_stop")
+
+    async def async_media_next_track(self) -> None:
+        """Forward media_next_track to sandbox."""
+        await self._forward_method("async_media_next_track")
+
+    async def async_media_previous_track(self) -> None:
+        """Forward media_previous_track to sandbox."""
+        await self._forward_method("async_media_previous_track")
+
+    async def async_media_seek(self, position: float) -> None:
+        """Forward media_seek to sandbox."""
+        await self._forward_method("async_media_seek", position=position)
+
+    async def async_select_source(self, source: str) -> None:
+        """Forward select_source to sandbox."""
+        await self._forward_method("async_select_source", source=source)
+
+    async def async_select_sound_mode(self, sound_mode: str) -> None:
+        """Forward select_sound_mode to sandbox."""
+        await self._forward_method("async_select_sound_mode", sound_mode=sound_mode)
+
+    async def async_play_media(self, media_type: str, media_id: str, **kwargs: Any) -> None:
+        """Forward play_media to sandbox."""
+        await self._forward_method("async_play_media", media_type=media_type, media_id=media_id, **kwargs)

homeassistant/components/sandbox/entity/notify.py

@@ -0,0 +1,26 @@
+"""Sandbox proxy for notify entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.notify import NotifyEntity, NotifyEntityFeature
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxNotifyEntity(SandboxProxyEntity, NotifyEntity):
+    """Proxy for a notify entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy notify entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = NotifyEntityFeature(
+            description.supported_features
+        )
+
+    async def async_send_message(self, message: str, title: str | None = None) -> None:
+        """Forward send_message to sandbox."""
+        await self._forward_method("async_send_message", message=message, title=title)

homeassistant/components/sandbox/entity/number.py

@@ -0,0 +1,42 @@
+"""Sandbox proxy for number entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.number import NumberEntity, NumberMode
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxNumberEntity(SandboxProxyEntity, NumberEntity):
+    """Proxy for a number entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy number entity."""
+        super().__init__(description, manager)
+        caps = description.capabilities
+        if (min_val := caps.get("native_min_value")) is not None:
+            self._attr_native_min_value = min_val
+        if (max_val := caps.get("native_max_value")) is not None:
+            self._attr_native_max_value = max_val
+        if (step := caps.get("native_step")) is not None:
+            self._attr_native_step = step
+        if unit := caps.get("native_unit_of_measurement"):
+            self._attr_native_unit_of_measurement = unit
+        if mode := caps.get("mode"):
+            self._attr_mode = NumberMode(mode)
+
+    @property
+    def native_value(self) -> float | None:
+        """Return the current value."""
+        val = self._state_cache.get("state")
+        if val is None:
+            return None
+        return float(val)
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Forward set_native_value to sandbox."""
+        await self._forward_method("async_set_native_value", value=value)

homeassistant/components/sandbox/entity/remote.py

@@ -0,0 +1,51 @@
+"""Sandbox proxy for remote entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.remote import RemoteEntity, RemoteEntityFeature
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxRemoteEntity(SandboxProxyEntity, RemoteEntity):
+    """Proxy for a remote entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy remote entity."""
+        super().__init__(description, manager)
+        self._attr_supported_features = RemoteEntityFeature(
+            description.supported_features
+        )
+        if activity_list := description.capabilities.get("activity_list"):
+            self._attr_activity_list = activity_list
+
+    @property
+    def is_on(self) -> bool | None:
+        """Return if the remote is on."""
+        state = self._state_cache.get("state")
+        if state is None:
+            return None
+        return state == "on"
+
+    @property
+    def current_activity(self) -> str | None:
+        """Return the current activity."""
+        return self._state_cache.get("current_activity")
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Forward turn_on to sandbox."""
+        await self._forward_method("async_turn_on", **kwargs)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Forward turn_off to sandbox."""
+        await self._forward_method("async_turn_off", **kwargs)
+
+    async def async_send_command(self, command: list[str], **kwargs: Any) -> None:
+        """Forward send_command to sandbox."""
+        await self._forward_method("async_send_command", command=command, **kwargs)

homeassistant/components/sandbox/entity/scene.py

@@ -0,0 +1,17 @@
+"""Sandbox proxy for scene entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.scene import Scene
+
+from . import SandboxProxyEntity
+
+
+class SandboxSceneEntity(SandboxProxyEntity, Scene):
+    """Proxy for a scene entity in a sandbox."""
+
+    async def async_activate(self, **kwargs: Any) -> None:
+        """Forward activate to sandbox."""
+        await self._forward_method("async_activate", **kwargs)

homeassistant/components/sandbox/entity/select.py

@@ -0,0 +1,29 @@
+"""Sandbox proxy for select entities."""
+
+from __future__ import annotations
+
+from homeassistant.components.select import SelectEntity
+
+from . import SandboxEntityDescription, SandboxEntityManager, SandboxProxyEntity
+
+
+class SandboxSelectEntity(SandboxProxyEntity, SelectEntity):
+    """Proxy for a select entity in a sandbox."""
+
+    def __init__(
+        self,
+        description: SandboxEntityDescription,
+        manager: SandboxEntityManager,
+    ) -> None:
+        """Initialize the proxy select entity."""
+        super().__init__(description, manager)
+        self._attr_options = description.capabilities.get("options", [])
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the current option."""
+        return self._state_cache.get("state")
+
+    async def async_select_option(self, option: str) -> None:
+        """Forward select_option to sandbox."""
+        await self._forward_method("async_select_option", option=option)