clean up name config for yaml entities

CODEOWNERS

@@ -1170,8 +1170,6 @@ build.json @home-assistant/supervisor
 /tests/components/open_router/ @joostlek
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
-/homeassistant/components/openevse/ @c00w
-/tests/components/openevse/ @c00w
 /homeassistant/components/openexchangerates/ @MartinHjelmare
 /tests/components/openexchangerates/ @MartinHjelmare
 /homeassistant/components/opengarage/ @danielhiversen

homeassistant/components/airobot/__init__.py

@@ -7,12 +7,7 @@ from homeassistant.core import HomeAssistant
 
 from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [
-    Platform.BUTTON,
-    Platform.CLIMATE,
-    Platform.NUMBER,
-    Platform.SENSOR,
-]
+PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.NUMBER, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:

homeassistant/components/airobot/button.py

@@ -1,89 +0,0 @@
-"""Button platform for Airobot integration."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Coroutine
-from dataclasses import dataclass
-from typing import Any
-
-from pyairobotrest.exceptions import (
-    AirobotConnectionError,
-    AirobotError,
-    AirobotTimeoutError,
-)
-
-from homeassistant.components.button import (
-    ButtonDeviceClass,
-    ButtonEntity,
-    ButtonEntityDescription,
-)
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import DOMAIN
-from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
-from .entity import AirobotEntity
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class AirobotButtonEntityDescription(ButtonEntityDescription):
-    """Describes Airobot button entity."""
-
-    press_fn: Callable[[AirobotDataUpdateCoordinator], Coroutine[Any, Any, None]]
-
-
-BUTTON_TYPES: tuple[AirobotButtonEntityDescription, ...] = (
-    AirobotButtonEntityDescription(
-        key="restart",
-        device_class=ButtonDeviceClass.RESTART,
-        entity_category=EntityCategory.CONFIG,
-        press_fn=lambda coordinator: coordinator.client.reboot_thermostat(),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AirobotConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Airobot button entities."""
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        AirobotButton(coordinator, description) for description in BUTTON_TYPES
-    )
-
-
-class AirobotButton(AirobotEntity, ButtonEntity):
-    """Representation of an Airobot button."""
-
-    entity_description: AirobotButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: AirobotDataUpdateCoordinator,
-        description: AirobotButtonEntityDescription,
-    ) -> None:
-        """Initialize the button."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        try:
-            await self.entity_description.press_fn(self.coordinator)
-        except (AirobotConnectionError, AirobotTimeoutError):
-            # Connection errors during reboot are expected as device restarts
-            pass
-        except AirobotError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="button_press_failed",
-                translation_placeholders={"button": self.entity_description.key},
-            ) from err

homeassistant/components/airobot/strings.json

@@ -86,9 +86,6 @@
     "authentication_failed": {
       "message": "Authentication failed, please reauthenticate."
     },
-    "button_press_failed": {
-      "message": "Failed to press {button} button."
-    },
     "connection_failed": {
       "message": "Failed to communicate with device."
     },

homeassistant/components/automation/__init__.py

@@ -136,7 +136,6 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "light",
     "lock",
     "media_player",
-    "person",
     "scene",
     "siren",
     "switch",

homeassistant/components/braviatv/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pybravia"],
-  "requirements": ["pybravia==0.4.1"],
+  "requirements": ["pybravia==0.3.4"],
   "ssdp": [
     {
       "manufacturer": "Sony Corporation",

homeassistant/components/dlna_dmr/manifest.json

@@ -9,7 +9,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["async_upnp_client"],
-  "requirements": ["async-upnp-client==0.46.2", "getmac==0.9.5"],
+  "requirements": ["async-upnp-client==0.46.1", "getmac==0.9.5"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/dlna_dms/manifest.json

@@ -8,7 +8,7 @@
   "documentation": "https://www.home-assistant.io/integrations/dlna_dms",
   "integration_type": "service",
   "iot_class": "local_polling",
-  "requirements": ["async-upnp-client==0.46.2"],
+  "requirements": ["async-upnp-client==0.46.1"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaServer:1",

homeassistant/components/duckdns/__init__.py

@@ -1,4 +1,4 @@
-"""Duck DNS integration."""
+"""Integrate with DuckDNS."""
 
 from __future__ import annotations
 

homeassistant/components/duckdns/services.py

@@ -2,12 +2,11 @@
 
 from __future__ import annotations
 
-from aiohttp import ClientError
 import voluptuous as vol
 
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
 from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import ConfigEntrySelector
@@ -63,25 +62,9 @@ async def update_domain_service(call: ServiceCall) -> None:
 
     session = async_get_clientsession(call.hass)
 
-    try:
-        if not await update_duckdns(
-            session,
-            entry.data[CONF_DOMAIN],
-            entry.data[CONF_ACCESS_TOKEN],
-            txt=call.data.get(ATTR_TXT),
-        ):
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="update_failed",
-                translation_placeholders={
-                    CONF_DOMAIN: entry.data[CONF_DOMAIN],
-                },
-            )
-    except ClientError as e:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="connection_error",
-            translation_placeholders={
-                CONF_DOMAIN: entry.data[CONF_DOMAIN],
-            },
-        ) from e
+    await update_duckdns(
+        session,
+        entry.data[CONF_DOMAIN],
+        entry.data[CONF_ACCESS_TOKEN],
+        txt=call.data.get(ATTR_TXT),
+    )

homeassistant/components/ecowitt/sensor.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import dataclasses
 from datetime import datetime
-import logging
 from typing import Final
 
 from aioecowitt import EcoWittSensor, EcoWittSensorTypes
@@ -40,9 +39,6 @@ from homeassistant.util.unit_system import METRIC_SYSTEM, US_CUSTOMARY_SYSTEM
 from . import EcowittConfigEntry
 from .entity import EcowittEntity
 
-_LOGGER = logging.getLogger(__name__)
-
-
 _METRIC: Final = (
     EcoWittSensorTypes.TEMPERATURE_C,
     EcoWittSensorTypes.RAIN_COUNT_MM,
@@ -61,40 +57,6 @@ _IMPERIAL: Final = (
 )
 
 
-_RAIN_COUNT_SENSORS_STATE_CLASS_MAPPING: Final = {
-    "eventrainin": SensorStateClass.TOTAL_INCREASING,
-    "hourlyrainin": None,
-    "totalrainin": SensorStateClass.TOTAL_INCREASING,
-    "dailyrainin": SensorStateClass.TOTAL_INCREASING,
-    "weeklyrainin": SensorStateClass.TOTAL_INCREASING,
-    "monthlyrainin": SensorStateClass.TOTAL_INCREASING,
-    "yearlyrainin": SensorStateClass.TOTAL_INCREASING,
-    "last24hrainin": None,
-    "eventrainmm": SensorStateClass.TOTAL_INCREASING,
-    "hourlyrainmm": None,
-    "totalrainmm": SensorStateClass.TOTAL_INCREASING,
-    "dailyrainmm": SensorStateClass.TOTAL_INCREASING,
-    "weeklyrainmm": SensorStateClass.TOTAL_INCREASING,
-    "monthlyrainmm": SensorStateClass.TOTAL_INCREASING,
-    "yearlyrainmm": SensorStateClass.TOTAL_INCREASING,
-    "last24hrainmm": None,
-    "erain_piezo": SensorStateClass.TOTAL_INCREASING,
-    "hrain_piezo": None,
-    "drain_piezo": SensorStateClass.TOTAL_INCREASING,
-    "wrain_piezo": SensorStateClass.TOTAL_INCREASING,
-    "mrain_piezo": SensorStateClass.TOTAL_INCREASING,
-    "yrain_piezo": SensorStateClass.TOTAL_INCREASING,
-    "last24hrain_piezo": None,
-    "erain_piezomm": SensorStateClass.TOTAL_INCREASING,
-    "hrain_piezomm": None,
-    "drain_piezomm": SensorStateClass.TOTAL_INCREASING,
-    "wrain_piezomm": SensorStateClass.TOTAL_INCREASING,
-    "mrain_piezomm": SensorStateClass.TOTAL_INCREASING,
-    "yrain_piezomm": SensorStateClass.TOTAL_INCREASING,
-    "last24hrain_piezomm": None,
-}
-
-
 ECOWITT_SENSORS_MAPPING: Final = {
     EcoWittSensorTypes.HUMIDITY: SensorEntityDescription(
         key="HUMIDITY",
@@ -323,15 +285,15 @@ async def async_setup_entry(
             name=sensor.name,
         )
 
-        if sensor.stype in (
-            EcoWittSensorTypes.RAIN_COUNT_INCHES,
-            EcoWittSensorTypes.RAIN_COUNT_MM,
+        # Only total rain needs state class for long-term statistics
+        if sensor.key in (
+            "totalrainin",
+            "totalrainmm",
         ):
-            if sensor.key not in _RAIN_COUNT_SENSORS_STATE_CLASS_MAPPING:
-                _LOGGER.warning("Unknown rain count sensor: %s", sensor.key)
-                return
-            state_class = _RAIN_COUNT_SENSORS_STATE_CLASS_MAPPING[sensor.key]
-            description = dataclasses.replace(description, state_class=state_class)
+            description = dataclasses.replace(
+                description,
+                state_class=SensorStateClass.TOTAL_INCREASING,
+            )
 
         async_add_entities([EcowittSensorEntity(sensor, description)])
 

homeassistant/components/eheimdigital/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["eheimdigital"],
   "quality_scale": "platinum",
-  "requirements": ["eheimdigital==1.5.0"],
+  "requirements": ["eheimdigital==1.4.0"],
   "zeroconf": [
     { "name": "eheimdigital._http._tcp.local.", "type": "_http._tcp.local." }
   ]

homeassistant/components/frontend/manifest.json

@@ -23,5 +23,5 @@
     "winter_mode": {}
   },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251229.1"]
+  "requirements": ["home-assistant-frontend==20251229.0"]
 }

homeassistant/components/google_generative_ai_conversation/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/google_generative_ai_conversation",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["google-genai==1.56.0"]
+  "requirements": ["google-genai==1.38.0"]
 }

homeassistant/components/homevolt/__init__.py

@@ -1,51 +0,0 @@
-"""The Homevolt integration."""
-
-from __future__ import annotations
-
-from homevolt import Homevolt, HomevoltConnectionError
-
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN, HomevoltConfigEntry
-from .coordinator import HomevoltDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.SENSOR]
-
-CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: HomevoltConfigEntry) -> bool:
-    """Set up Homevolt from a config entry."""
-    host: str = entry.data[CONF_HOST]
-    password: str | None = entry.data.get(CONF_PASSWORD)
-
-    websession = async_get_clientsession(hass)
-    client = Homevolt(host, password, websession=websession)
-
-    try:
-        await client.update_info()
-    except HomevoltConnectionError as err:
-        raise ConfigEntryNotReady(
-            f"Unable to connect to Homevolt battery: {err}"
-        ) from err
-
-    coordinator = HomevoltDataUpdateCoordinator(hass, entry, client)
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: HomevoltConfigEntry) -> bool:
-    """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        if entry.runtime_data:
-            await entry.runtime_data.client.close_connection()
-    return unload_ok

homeassistant/components/homevolt/config_flow.py

@@ -1,63 +0,0 @@
-"""Config flow for the Homevolt integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from homevolt import Homevolt, HomevoltAuthenticationError, HomevoltConnectionError
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_PASSWORD
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_HOST): str,
-        vol.Optional(CONF_PASSWORD): str,
-    }
-)
-
-
-class HomevoltConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Homevolt."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            host = user_input[CONF_HOST]
-            password = user_input.get(CONF_PASSWORD)
-            websession = async_get_clientsession(self.hass)
-            try:
-                await Homevolt(host, password, websession=websession).update_info()
-            except HomevoltAuthenticationError:
-                errors["base"] = "invalid_auth"
-            except HomevoltConnectionError:
-                errors["base"] = "cannot_connect"
-            except Exception:  # noqa: BLE001
-                errors["base"] = "unknown"
-            else:
-                await self.async_set_unique_id(host)
-                self._abort_if_unique_id_configured()
-
-                return self.async_create_entry(
-                    title="Homevolt Local",
-                    data={
-                        CONF_HOST: host,
-                        CONF_PASSWORD: password,
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/homevolt/const.py

@@ -1,16 +0,0 @@
-"""Constants for the Homevolt integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-from typing import TYPE_CHECKING
-
-from homeassistant.config_entries import ConfigEntry
-
-if TYPE_CHECKING:
-    from .coordinator import HomevoltDataUpdateCoordinator
-
-DOMAIN = "homevolt"
-MANUFACTURER = "Homevolt"
-SCAN_INTERVAL = timedelta(seconds=15)
-type HomevoltConfigEntry = ConfigEntry["HomevoltDataUpdateCoordinator"]

homeassistant/components/homevolt/coordinator.py

@@ -1,51 +0,0 @@
-"""Data update coordinator for Homevolt integration."""
-
-from __future__ import annotations
-
-import logging
-
-from homevolt import (
-    Device,
-    Homevolt,
-    HomevoltAuthenticationError,
-    HomevoltConnectionError,
-    HomevoltError,
-)
-
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN, SCAN_INTERVAL, HomevoltConfigEntry
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class HomevoltDataUpdateCoordinator(DataUpdateCoordinator[Device]):
-    """Class to manage fetching Homevolt data."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: HomevoltConfigEntry,
-        client: Homevolt,
-    ) -> None:
-        """Initialize the Homevolt coordinator."""
-        self.client = client
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=DOMAIN,
-            update_interval=SCAN_INTERVAL,
-            config_entry=entry,
-        )
-
-    async def _async_update_data(self) -> Device:
-        """Fetch data from the Homevolt API."""
-        try:
-            await self.client.update_info()
-            return self.client.get_device()
-        except HomevoltAuthenticationError as err:
-            raise ConfigEntryAuthFailed from err
-        except (HomevoltConnectionError, HomevoltError) as err:
-            raise UpdateFailed(f"Error communicating with device: {err}") from err

homeassistant/components/homevolt/manifest.json

@@ -1,15 +0,0 @@
-{
-  "domain": "homevolt",
-  "name": "Homevolt",
-  "codeowners": ["@danielhiversen"],
-  "config_flow": true,
-  "dependencies": [],
-  "documentation": "https://www.home-assistant.io/integrations/homevolt",
-  "homekit": {},
-  "integration_type": "device",
-  "iot_class": "local_polling",
-  "quality_scale": "bronze",
-  "requirements": ["homevolt==0.2.3"],
-  "ssdp": [],
-  "zeroconf": []
-}

homeassistant/components/homevolt/quality_scale.yaml

@@ -1,72 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register custom actions.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: Integration does not register custom actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Local_polling without events
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: Integration does not register custom actions.
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: Integration does not have an options flow.
-  docs-installation-parameters: todo
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates:
-    status: exempt
-    comment: Coordinator handles updates, no explicit parallel updates needed.
-  reauthentication-flow: todo
-  test-coverage: todo
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info: todo
-  discovery: todo
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: done
-  entity-disabled-by-default: todo
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/homevolt/sensor.py

@@ -1,167 +0,0 @@
-"""Support for Homevolt sensors."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-
-from homevolt.models import SensorType
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import (
-    PERCENTAGE,
-    SIGNAL_STRENGTH_DECIBELS,
-    UnitOfElectricCurrent,
-    UnitOfElectricPotential,
-    UnitOfEnergy,
-    UnitOfFrequency,
-    UnitOfPower,
-    UnitOfTemperature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.typing import StateType
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN, MANUFACTURER, HomevoltConfigEntry
-from .coordinator import HomevoltDataUpdateCoordinator
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass
-class Description:
-    """Sensor metadata description."""
-
-    device_class: SensorDeviceClass | None
-    state_class: SensorStateClass | None
-    native_unit_of_measurement: str | None
-
-
-SENSOR_META: dict[SensorType, Description] = {
-    SensorType.COUNT: Description(
-        None,
-        SensorStateClass.MEASUREMENT,
-        "N",
-    ),
-    SensorType.CURRENT: Description(
-        SensorDeviceClass.CURRENT,
-        SensorStateClass.MEASUREMENT,
-        UnitOfElectricCurrent.AMPERE,
-    ),
-    SensorType.ENERGY_INCREASING: Description(
-        SensorDeviceClass.ENERGY,
-        SensorStateClass.TOTAL_INCREASING,
-        UnitOfEnergy.KILO_WATT_HOUR,
-    ),
-    SensorType.ENERGY_TOTAL: Description(
-        SensorDeviceClass.ENERGY,
-        SensorStateClass.TOTAL,
-        UnitOfEnergy.WATT_HOUR,
-    ),
-    SensorType.FREQUENCY: Description(
-        SensorDeviceClass.FREQUENCY,
-        SensorStateClass.MEASUREMENT,
-        UnitOfFrequency.HERTZ,
-    ),
-    SensorType.PERCENTAGE: Description(
-        SensorDeviceClass.BATTERY,
-        SensorStateClass.MEASUREMENT,
-        PERCENTAGE,
-    ),
-    SensorType.POWER: Description(
-        SensorDeviceClass.POWER,
-        SensorStateClass.MEASUREMENT,
-        UnitOfPower.WATT,
-    ),
-    SensorType.SCHEDULE_TYPE: Description(
-        None,
-        None,
-        None,
-    ),
-    SensorType.SIGNAL_STRENGTH: Description(
-        SensorDeviceClass.SIGNAL_STRENGTH,
-        SensorStateClass.MEASUREMENT,
-        SIGNAL_STRENGTH_DECIBELS,
-    ),
-    SensorType.TEMPERATURE: Description(
-        SensorDeviceClass.TEMPERATURE,
-        SensorStateClass.MEASUREMENT,
-        UnitOfTemperature.CELSIUS,
-    ),
-    SensorType.TEXT: Description(
-        None,
-        None,
-        None,
-    ),
-    SensorType.VOLTAGE: Description(
-        SensorDeviceClass.VOLTAGE,
-        SensorStateClass.MEASUREMENT,
-        UnitOfElectricPotential.VOLT,
-    ),
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: HomevoltConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Homevolt sensor."""
-    coordinator = entry.runtime_data
-    entities = []
-    for sensor_name, sensor in coordinator.data.sensors.items():
-        if sensor.type not in SENSOR_META:
-            continue
-        sensor_meta = SENSOR_META[sensor.type]
-        entities.append(
-            HomevoltSensor(
-                SensorEntityDescription(
-                    key=sensor_name,
-                    name=sensor_name,
-                    device_class=sensor_meta.device_class,
-                    state_class=sensor_meta.state_class,
-                    native_unit_of_measurement=sensor_meta.native_unit_of_measurement,
-                ),
-                coordinator,
-            )
-        )
-    async_add_entities(entities)
-
-
-class HomevoltSensor(CoordinatorEntity[HomevoltDataUpdateCoordinator], SensorEntity):
-    """Representation of a Homevolt sensor."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        description: SensorEntityDescription,
-        coordinator: HomevoltDataUpdateCoordinator,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        device_id = coordinator.data.device_id
-        self._attr_unique_id = f"{device_id}_{description.key}"
-        sensor = coordinator.data.sensors[description.key]
-        sensor_device_id = sensor.device_identifier
-        device_metadata = coordinator.data.device_metadata.get(sensor_device_id)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"{device_id}_{sensor_device_id}")},
-            configuration_url=coordinator.client.hostname,
-            manufacturer=MANUFACTURER,
-            model=device_metadata.model,
-            name=device_metadata.name,
-        )
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the native value of the sensor."""
-        return self.coordinator.data.sensors[self.entity_description.key].value

homeassistant/components/homevolt/strings.json

@@ -1,26 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]",
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "host": "The IP address or hostname of your Homevolt battery on your local network.",
-          "password": "The local password configured for your Homevolt battery, if required."
-        },
-        "description": "Connect Home Assistant to your Homevolt battery over the local network.",
-        "title": "Homevolt Local"
-      }
-    }
-  }
-}

homeassistant/components/hue_ble/manifest.json

@@ -4,8 +4,7 @@
   "bluetooth": [
     {
       "connectable": true,
-      "service_data_uuid": "0000fe0f-0000-1000-8000-00805f9b34fb",
-      "service_uuid": "0000fe0f-0000-1000-8000-00805f9b34fb"
+      "service_data_uuid": "0000fe0f-0000-1000-8000-00805f9b34fb"
     }
   ],
   "codeowners": ["@flip-dots"],

homeassistant/components/humidifier/icons.json

@@ -66,7 +66,7 @@
       "trigger": "mdi:air-humidifier-off"
     },
     "turned_on": {
-      "trigger": "mdi:air-humidifier"
+      "trigger": "mdi:air-humidifier-on"
     }
   }
 }

homeassistant/components/knx/binary_sensor.py

@@ -114,24 +114,26 @@ class KnxYamlBinarySensor(_KnxBinarySensor, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize of KNX binary sensor."""
+        self._device = XknxBinarySensor(
+            xknx=knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            group_address_state=config[CONF_STATE_ADDRESS],
+            invert=config[CONF_INVERT],
+            sync_state=config[CONF_SYNC_STATE],
+            ignore_internal_state=config[CONF_IGNORE_INTERNAL_STATE],
+            context_timeout=config.get(CONF_CONTEXT_TIMEOUT),
+            reset_after=config.get(CONF_RESET_AFTER),
+            always_callback=True,
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxBinarySensor(
-                xknx=knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address_state=config[CONF_STATE_ADDRESS],
-                invert=config[CONF_INVERT],
-                sync_state=config[CONF_SYNC_STATE],
-                ignore_internal_state=config[CONF_IGNORE_INTERNAL_STATE],
-                context_timeout=config.get(CONF_CONTEXT_TIMEOUT),
-                reset_after=config.get(CONF_RESET_AFTER),
-                always_callback=True,
-            ),
+            unique_id=str(self._device.remote_value.group_address_state),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
+
         self._attr_device_class = config.get(CONF_DEVICE_CLASS)
         self._attr_force_update = self._device.ignore_internal_state
-        self._attr_unique_id = str(self._device.remote_value.group_address_state)
 
 
 class KnxUiBinarySensor(_KnxBinarySensor, KnxUiEntity):

homeassistant/components/knx/button.py

@@ -35,19 +35,18 @@ class KNXButton(KnxYamlEntity, ButtonEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX button."""
-        super().__init__(
-            knx_module=knx_module,
-            device=XknxRawValue(
-                xknx=knx_module.xknx,
-                name=config[CONF_NAME],
-                payload_length=config[CONF_PAYLOAD_LENGTH],
-                group_address=config[KNX_ADDRESS],
-            ),
+        self._device = XknxRawValue(
+            xknx=knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            payload_length=config[CONF_PAYLOAD_LENGTH],
+            group_address=config[KNX_ADDRESS],
         )
         self._payload = config[CONF_PAYLOAD]
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = (
-            f"{self._device.remote_value.group_address}_{self._payload}"
+        super().__init__(
+            knx_module=knx_module,
+            unique_id=f"{self._device.remote_value.group_address}_{self._payload}",
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
 
     async def async_press(self) -> None:

homeassistant/components/knx/climate.py

@@ -119,11 +119,11 @@ async def async_setup_entry(
         async_add_entities(entities)
 
 
-def _create_climate(xknx: XKNX, config: ConfigType) -> XknxClimate:
+def _create_climate_yaml(xknx: XKNX, config: ConfigType) -> XknxClimate:
     """Return a KNX Climate device to be used within XKNX."""
     climate_mode = XknxClimateMode(
         xknx,
-        name=f"{config[CONF_NAME]} Mode",
+        name=f"{config.get(CONF_NAME, '')} Mode",
         group_address_operation_mode=config.get(
             ClimateSchema.CONF_OPERATION_MODE_ADDRESS
         ),
@@ -164,7 +164,7 @@ def _create_climate(xknx: XKNX, config: ConfigType) -> XknxClimate:
 
     return XknxClimate(
         xknx,
-        name=config[CONF_NAME],
+        name=config.get(CONF_NAME, ""),
         group_address_temperature=config[ClimateSchema.CONF_TEMPERATURE_ADDRESS],
         group_address_target_temperature=config.get(
             ClimateSchema.CONF_TARGET_TEMPERATURE_ADDRESS
@@ -647,9 +647,17 @@ class KnxYamlClimate(_KnxClimate, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize of a KNX climate device."""
+        self._device = _create_climate_yaml(knx_module.xknx, config)
         super().__init__(
             knx_module=knx_module,
-            device=_create_climate(knx_module.xknx, config),
+            unique_id=(
+                f"{self._device.temperature.group_address_state}_"
+                f"{self._device.target_temperature.group_address_state}_"
+                f"{self._device.target_temperature.group_address}_"
+                f"{self._device._setpoint_shift.group_address}"  # noqa: SLF001
+            ),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         default_hvac_mode: HVACMode = config[ClimateConf.DEFAULT_CONTROLLER_MODE]
         fan_max_step = config[ClimateConf.FAN_MAX_STEP]
@@ -661,14 +669,6 @@ class KnxYamlClimate(_KnxClimate, KnxYamlEntity):
             fan_zero_mode=fan_zero_mode,
         )
 
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = (
-            f"{self._device.temperature.group_address_state}_"
-            f"{self._device.target_temperature.group_address_state}_"
-            f"{self._device.target_temperature.group_address}_"
-            f"{self._device._setpoint_shift.group_address}"  # noqa: SLF001
-        )
-
 
 class KnxUiClimate(_KnxClimate, KnxUiEntity):
     """Representation of a KNX climate device configured from the UI."""

homeassistant/components/knx/cover.py

@@ -191,36 +191,34 @@ class KnxYamlCover(_KnxCover, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize the cover."""
+        self._device = XknxCover(
+            xknx=knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            group_address_long=config.get(CoverSchema.CONF_MOVE_LONG_ADDRESS),
+            group_address_short=config.get(CoverSchema.CONF_MOVE_SHORT_ADDRESS),
+            group_address_stop=config.get(CoverSchema.CONF_STOP_ADDRESS),
+            group_address_position_state=config.get(
+                CoverSchema.CONF_POSITION_STATE_ADDRESS
+            ),
+            group_address_angle=config.get(CoverSchema.CONF_ANGLE_ADDRESS),
+            group_address_angle_state=config.get(CoverSchema.CONF_ANGLE_STATE_ADDRESS),
+            group_address_position=config.get(CoverSchema.CONF_POSITION_ADDRESS),
+            travel_time_down=config[CoverConf.TRAVELLING_TIME_DOWN],
+            travel_time_up=config[CoverConf.TRAVELLING_TIME_UP],
+            invert_updown=config[CoverConf.INVERT_UPDOWN],
+            invert_position=config[CoverConf.INVERT_POSITION],
+            invert_angle=config[CoverConf.INVERT_ANGLE],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxCover(
-                xknx=knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address_long=config.get(CoverSchema.CONF_MOVE_LONG_ADDRESS),
-                group_address_short=config.get(CoverSchema.CONF_MOVE_SHORT_ADDRESS),
-                group_address_stop=config.get(CoverSchema.CONF_STOP_ADDRESS),
-                group_address_position_state=config.get(
-                    CoverSchema.CONF_POSITION_STATE_ADDRESS
-                ),
-                group_address_angle=config.get(CoverSchema.CONF_ANGLE_ADDRESS),
-                group_address_angle_state=config.get(
-                    CoverSchema.CONF_ANGLE_STATE_ADDRESS
-                ),
-                group_address_position=config.get(CoverSchema.CONF_POSITION_ADDRESS),
-                travel_time_down=config[CoverConf.TRAVELLING_TIME_DOWN],
-                travel_time_up=config[CoverConf.TRAVELLING_TIME_UP],
-                invert_updown=config[CoverConf.INVERT_UPDOWN],
-                invert_position=config[CoverConf.INVERT_POSITION],
-                invert_angle=config[CoverConf.INVERT_ANGLE],
+            unique_id=(
+                f"{self._device.updown.group_address}_"
+                f"{self._device.position_target.group_address}"
             ),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         self.init_base()
-
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = (
-            f"{self._device.updown.group_address}_"
-            f"{self._device.position_target.group_address}"
-        )
         if custom_device_class := config.get(CONF_DEVICE_CLASS):
             self._attr_device_class = custom_device_class
 

homeassistant/components/knx/date.py

@@ -105,20 +105,21 @@ class KnxYamlDate(_KNXDate, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX date."""
+        self._device = XknxDateDevice(
+            knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            localtime=False,
+            group_address=config[KNX_ADDRESS],
+            group_address_state=config.get(CONF_STATE_ADDRESS),
+            respond_to_read=config[CONF_RESPOND_TO_READ],
+            sync_state=config[CONF_SYNC_STATE],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxDateDevice(
-                knx_module.xknx,
-                name=config[CONF_NAME],
-                localtime=False,
-                group_address=config[KNX_ADDRESS],
-                group_address_state=config.get(CONF_STATE_ADDRESS),
-                respond_to_read=config[CONF_RESPOND_TO_READ],
-                sync_state=config[CONF_SYNC_STATE],
-            ),
+            unique_id=str(self._device.remote_value.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.remote_value.group_address)
 
 
 class KnxUiDate(_KNXDate, KnxUiEntity):

homeassistant/components/knx/datetime.py

@@ -110,20 +110,21 @@ class KnxYamlDateTime(_KNXDateTime, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX datetime."""
+        self._device = XknxDateTimeDevice(
+            knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            localtime=False,
+            group_address=config[KNX_ADDRESS],
+            group_address_state=config.get(CONF_STATE_ADDRESS),
+            respond_to_read=config[CONF_RESPOND_TO_READ],
+            sync_state=config[CONF_SYNC_STATE],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxDateTimeDevice(
-                knx_module.xknx,
-                name=config[CONF_NAME],
-                localtime=False,
-                group_address=config[KNX_ADDRESS],
-                group_address_state=config.get(CONF_STATE_ADDRESS),
-                respond_to_read=config[CONF_RESPOND_TO_READ],
-                sync_state=config[CONF_SYNC_STATE],
-            ),
+            unique_id=str(self._device.remote_value.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.remote_value.group_address)
 
 
 class KnxUiDateTime(_KNXDateTime, KnxUiEntity):

homeassistant/components/knx/entity.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any
 
 from xknx.devices import Device as XknxDevice
 
-from homeassistant.const import CONF_ENTITY_CATEGORY, EntityCategory
+from homeassistant.const import CONF_ENTITY_CATEGORY, CONF_NAME, EntityCategory
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import EntityPlatform
@@ -52,14 +52,11 @@ class _KnxEntityBase(Entity):
     """Representation of a KNX entity."""
 
     _attr_should_poll = False
+
+    _attr_unique_id: str
     _knx_module: KNXModule
     _device: XknxDevice
 
-    @property
-    def name(self) -> str:
-        """Return the name of the KNX device."""
-        return self._device.name
-
     @property
     def available(self) -> bool:
         """Return True if entity is available."""
@@ -100,16 +97,23 @@ class _KnxEntityBase(Entity):
 class KnxYamlEntity(_KnxEntityBase):
     """Representation of a KNX entity configured from YAML."""
 
-    def __init__(self, knx_module: KNXModule, device: XknxDevice) -> None:
+    def __init__(
+        self,
+        knx_module: KNXModule,
+        unique_id: str,
+        name: str | None,
+        entity_category: EntityCategory | None,
+    ) -> None:
         """Initialize the YAML entity."""
         self._knx_module = knx_module
-        self._device = device
+        self._attr_name = name
+        self._attr_unique_id = unique_id
+        self._attr_entity_category = entity_category
 
 
 class KnxUiEntity(_KnxEntityBase):
     """Representation of a KNX UI entity."""
 
-    _attr_unique_id: str
     _attr_has_entity_name = True
 
     def __init__(
@@ -117,6 +121,8 @@ class KnxUiEntity(_KnxEntityBase):
     ) -> None:
         """Initialize the UI entity."""
         self._knx_module = knx_module
+
+        self._attr_name = entity_config[CONF_NAME]
         self._attr_unique_id = unique_id
         if entity_category := entity_config.get(CONF_ENTITY_CATEGORY):
             self._attr_entity_category = EntityCategory(entity_category)

homeassistant/components/knx/fan.py

@@ -152,32 +152,28 @@ class KnxYamlFan(_KnxFan, KnxYamlEntity):
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize of KNX fan."""
         max_step = config.get(FanConf.MAX_STEP)
+        self._device = XknxFan(
+            xknx=knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            group_address_speed=config.get(KNX_ADDRESS),
+            group_address_speed_state=config.get(FanSchema.CONF_STATE_ADDRESS),
+            group_address_oscillation=config.get(FanSchema.CONF_OSCILLATION_ADDRESS),
+            group_address_oscillation_state=config.get(
+                FanSchema.CONF_OSCILLATION_STATE_ADDRESS
+            ),
+            group_address_switch=config.get(FanSchema.CONF_SWITCH_ADDRESS),
+            group_address_switch_state=config.get(FanSchema.CONF_SWITCH_STATE_ADDRESS),
+            max_step=max_step,
+            sync_state=config.get(CONF_SYNC_STATE, True),
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxFan(
-                xknx=knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address_speed=config.get(KNX_ADDRESS),
-                group_address_speed_state=config.get(FanSchema.CONF_STATE_ADDRESS),
-                group_address_oscillation=config.get(
-                    FanSchema.CONF_OSCILLATION_ADDRESS
-                ),
-                group_address_oscillation_state=config.get(
-                    FanSchema.CONF_OSCILLATION_STATE_ADDRESS
-                ),
-                group_address_switch=config.get(FanSchema.CONF_SWITCH_ADDRESS),
-                group_address_switch_state=config.get(
-                    FanSchema.CONF_SWITCH_STATE_ADDRESS
-                ),
-                max_step=max_step,
-                sync_state=config.get(CONF_SYNC_STATE, True),
-            ),
+            unique_id=str(self._device.speed.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         # FanSpeedMode.STEP if max_step is set
         self._step_range: tuple[int, int] | None = (1, max_step) if max_step else None
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-
-        self._attr_unique_id = str(self._device.speed.group_address)
 
 
 class KnxUiFan(_KnxFan, KnxUiEntity):

homeassistant/components/knx/light.py

@@ -121,7 +121,7 @@ def _create_yaml_light(xknx: XKNX, config: ConfigType) -> XknxLight:
 
     return XknxLight(
         xknx,
-        name=config[CONF_NAME],
+        name=config.get(CONF_NAME, ""),
         group_address_switch=config.get(KNX_ADDRESS),
         group_address_switch_state=config.get(LightSchema.CONF_STATE_ADDRESS),
         group_address_brightness=config.get(LightSchema.CONF_BRIGHTNESS_ADDRESS),
@@ -558,15 +558,16 @@ class KnxYamlLight(_KnxLight, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize of KNX light."""
+        self._device = _create_yaml_light(knx_module.xknx, config)
         super().__init__(
             knx_module=knx_module,
-            device=_create_yaml_light(knx_module.xknx, config),
+            unique_id=self._device_unique_id(),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         self._attr_color_mode = next(iter(self.supported_color_modes))
         self._attr_max_color_temp_kelvin: int = config[LightSchema.CONF_MAX_KELVIN]
         self._attr_min_color_temp_kelvin: int = config[LightSchema.CONF_MIN_KELVIN]
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = self._device_unique_id()
 
     def _device_unique_id(self) -> str:
         """Return unique id for this device."""

homeassistant/components/knx/notify.py

@@ -33,7 +33,7 @@ def _create_notification_instance(xknx: XKNX, config: ConfigType) -> XknxNotific
     """Return a KNX Notification to be used within XKNX."""
     return XknxNotification(
         xknx,
-        name=config[CONF_NAME],
+        name=config.get(CONF_NAME, ""),
         group_address=config[KNX_ADDRESS],
         value_type=config[CONF_TYPE],
     )
@@ -46,12 +46,13 @@ class KNXNotify(KnxYamlEntity, NotifyEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX notification."""
+        self._device = _create_notification_instance(knx_module.xknx, config)
         super().__init__(
             knx_module=knx_module,
-            device=_create_notification_instance(knx_module.xknx, config),
+            unique_id=str(self._device.remote_value.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.remote_value.group_address)
 
     async def async_send_message(self, message: str, title: str | None = None) -> None:
         """Send a notification to knx bus."""

homeassistant/components/knx/number.py

@@ -44,7 +44,7 @@ def _create_numeric_value(xknx: XKNX, config: ConfigType) -> NumericValue:
     """Return a KNX NumericValue to be used within XKNX."""
     return NumericValue(
         xknx,
-        name=config[CONF_NAME],
+        name=config.get(CONF_NAME, ""),
         group_address=config[KNX_ADDRESS],
         group_address_state=config.get(CONF_STATE_ADDRESS),
         respond_to_read=config[CONF_RESPOND_TO_READ],
@@ -59,9 +59,12 @@ class KNXNumber(KnxYamlEntity, RestoreNumber):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX number."""
+        self._device = _create_numeric_value(knx_module.xknx, config)
         super().__init__(
             knx_module=knx_module,
-            device=_create_numeric_value(knx_module.xknx, config),
+            unique_id=str(self._device.sensor_value.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         self._attr_native_max_value = config.get(
             NumberSchema.CONF_MAX,
@@ -76,8 +79,6 @@ class KNXNumber(KnxYamlEntity, RestoreNumber):
             NumberSchema.CONF_STEP,
             self._device.sensor_value.dpt_class.resolution,
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.sensor_value.group_address)
         self._attr_native_unit_of_measurement = self._device.unit_of_measurement()
         self._device.sensor_value.value = max(0, self._attr_native_min_value)
 

homeassistant/components/knx/scene.py

@@ -83,18 +83,19 @@ class KnxYamlScene(_KnxScene, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize KNX scene."""
+        self._device = XknxScene(
+            xknx=knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            group_address=config[KNX_ADDRESS],
+            scene_number=config[SceneSchema.CONF_SCENE_NUMBER],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxScene(
-                xknx=knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address=config[KNX_ADDRESS],
-                scene_number=config[SceneSchema.CONF_SCENE_NUMBER],
+            unique_id=(
+                f"{self._device.scene_value.group_address}_{self._device.scene_number}"
             ),
-        )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = (
-            f"{self._device.scene_value.group_address}_{self._device.scene_number}"
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
 
 

homeassistant/components/knx/schema.py

@@ -214,16 +214,22 @@ class KNXPlatformSchema(ABC):
         }
 
 
+COMMON_ENTITY_SCHEMA = vol.Schema(
+    {
+        vol.Optional(CONF_NAME): cv.string,
+        vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
+    }
+)
+
+
 class BinarySensorSchema(KNXPlatformSchema):
     """Voluptuous schema for KNX binary sensors."""
 
     PLATFORM = Platform.BINARY_SENSOR
-    DEFAULT_NAME = "KNX Binary Sensor"
 
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
                 vol.Optional(CONF_IGNORE_INTERNAL_STATE, default=False): cv.boolean,
                 vol.Optional(CONF_INVERT, default=False): cv.boolean,
@@ -233,7 +239,6 @@ class BinarySensorSchema(KNXPlatformSchema):
                 ),
                 vol.Optional(CONF_DEVICE_CLASS): BINARY_SENSOR_DEVICE_CLASSES_SCHEMA,
                 vol.Optional(CONF_RESET_AFTER): cv.positive_float,
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),
     )
@@ -245,7 +250,6 @@ class ButtonSchema(KNXPlatformSchema):
     PLATFORM = Platform.BUTTON
 
     CONF_VALUE = "value"
-    DEFAULT_NAME = "KNX Button"
 
     payload_or_value_msg = f"Please use only one of `{CONF_PAYLOAD}` or `{CONF_VALUE}`"
     length_or_type_msg = (
@@ -253,9 +257,8 @@ class ButtonSchema(KNXPlatformSchema):
     )
 
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Required(KNX_ADDRESS): ga_validator,
                 vol.Exclusive(
                     CONF_PAYLOAD, "payload_or_value", msg=payload_or_value_msg
@@ -269,7 +272,6 @@ class ButtonSchema(KNXPlatformSchema):
                 vol.Exclusive(
                     CONF_TYPE, "length_or_type", msg=length_or_type_msg
                 ): object,
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),
         vol.Any(
@@ -337,7 +339,6 @@ class ClimateSchema(KNXPlatformSchema):
     CONF_SWING_HORIZONTAL_ADDRESS = "swing_horizontal_address"
     CONF_SWING_HORIZONTAL_STATE_ADDRESS = "swing_horizontal_state_address"
 
-    DEFAULT_NAME = "KNX Climate"
     DEFAULT_SETPOINT_SHIFT_MODE = "DPT6010"
     DEFAULT_SETPOINT_SHIFT_MAX = 6
     DEFAULT_SETPOINT_SHIFT_MIN = -6
@@ -346,9 +347,8 @@ class ClimateSchema(KNXPlatformSchema):
     DEFAULT_FAN_SPEED_MODE = "percent"
 
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Optional(
                     ClimateConf.SETPOINT_SHIFT_MAX, default=DEFAULT_SETPOINT_SHIFT_MAX
                 ): vol.All(int, vol.Range(min=0, max=32)),
@@ -448,12 +448,10 @@ class CoverSchema(KNXPlatformSchema):
     CONF_ANGLE_STATE_ADDRESS = "angle_state_address"
 
     DEFAULT_TRAVEL_TIME = 25
-    DEFAULT_NAME = "KNX Cover"
 
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Optional(CONF_MOVE_LONG_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_MOVE_SHORT_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_STOP_ADDRESS): ga_list_validator,
@@ -471,7 +469,6 @@ class CoverSchema(KNXPlatformSchema):
                 vol.Optional(CoverConf.INVERT_POSITION, default=False): cv.boolean,
                 vol.Optional(CoverConf.INVERT_ANGLE, default=False): cv.boolean,
                 vol.Optional(CONF_DEVICE_CLASS): COVER_DEVICE_CLASSES_SCHEMA,
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),
         vol.Any(
@@ -496,16 +493,12 @@ class DateSchema(KNXPlatformSchema):
 
     PLATFORM = Platform.DATE
 
-    DEFAULT_NAME = "KNX Date"
-
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_RESPOND_TO_READ, default=False): cv.boolean,
             vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
             vol.Required(KNX_ADDRESS): ga_list_validator,
             vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -515,16 +508,12 @@ class DateTimeSchema(KNXPlatformSchema):
 
     PLATFORM = Platform.DATETIME
 
-    DEFAULT_NAME = "KNX DateTime"
-
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_RESPOND_TO_READ, default=False): cv.boolean,
             vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
             vol.Required(KNX_ADDRESS): ga_list_validator,
             vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -580,12 +569,9 @@ class FanSchema(KNXPlatformSchema):
     CONF_SWITCH_ADDRESS = "switch_address"
     CONF_SWITCH_STATE_ADDRESS = "switch_state_address"
 
-    DEFAULT_NAME = "KNX Fan"
-
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Optional(KNX_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_SWITCH_ADDRESS): ga_list_validator,
@@ -593,7 +579,6 @@ class FanSchema(KNXPlatformSchema):
                 vol.Optional(CONF_OSCILLATION_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_OSCILLATION_STATE_ADDRESS): ga_list_validator,
                 vol.Optional(FanConf.MAX_STEP): cv.byte,
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
                 vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
             }
         ),
@@ -638,7 +623,6 @@ class LightSchema(KNXPlatformSchema):
     CONF_MIN_KELVIN = "min_kelvin"
     CONF_MAX_KELVIN = "max_kelvin"
 
-    DEFAULT_NAME = "KNX Light"
     DEFAULT_COLOR_TEMP_MODE = "absolute"
     DEFAULT_MIN_KELVIN = 2700  # 370 mireds
     DEFAULT_MAX_KELVIN = 6000  # 166 mireds
@@ -670,9 +654,8 @@ class LightSchema(KNXPlatformSchema):
     )
 
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Optional(KNX_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_BRIGHTNESS_ADDRESS): ga_list_validator,
@@ -722,7 +705,6 @@ class LightSchema(KNXPlatformSchema):
                 vol.Optional(CONF_MAX_KELVIN, default=DEFAULT_MAX_KELVIN): vol.All(
                     vol.Coerce(int), vol.Range(min=1)
                 ),
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),
         vol.Any(
@@ -768,14 +750,10 @@ class NotifySchema(KNXPlatformSchema):
 
     PLATFORM = Platform.NOTIFY
 
-    DEFAULT_NAME = "KNX Notify"
-
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_TYPE, default="latin_1"): string_type_validator,
             vol.Required(KNX_ADDRESS): ga_validator,
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -788,12 +766,10 @@ class NumberSchema(KNXPlatformSchema):
     CONF_MAX = "max"
     CONF_MIN = "min"
     CONF_STEP = "step"
-    DEFAULT_NAME = "KNX Number"
 
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Optional(CONF_RESPOND_TO_READ, default=False): cv.boolean,
                 vol.Optional(CONF_MODE, default=NumberMode.AUTO): vol.Coerce(
                     NumberMode
@@ -804,7 +780,6 @@ class NumberSchema(KNXPlatformSchema):
                 vol.Optional(CONF_MAX): vol.Coerce(float),
                 vol.Optional(CONF_MIN): vol.Coerce(float),
                 vol.Optional(CONF_STEP): cv.positive_float,
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),
         number_limit_sub_validator,
@@ -818,15 +793,12 @@ class SceneSchema(KNXPlatformSchema):
 
     CONF_SCENE_NUMBER = "scene_number"
 
-    DEFAULT_NAME = "KNX SCENE"
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Required(KNX_ADDRESS): ga_list_validator,
             vol.Required(SceneConf.SCENE_NUMBER): vol.All(
                 vol.Coerce(int), vol.Range(min=1, max=64)
             ),
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -838,12 +810,10 @@ class SelectSchema(KNXPlatformSchema):
 
     CONF_OPTION = "option"
     CONF_OPTIONS = "options"
-    DEFAULT_NAME = "KNX Select"
 
     ENTITY_SCHEMA = vol.All(
-        vol.Schema(
+        COMMON_ENTITY_SCHEMA.extend(
             {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
                 vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
                 vol.Optional(CONF_RESPOND_TO_READ, default=False): cv.boolean,
                 vol.Required(CONF_PAYLOAD_LENGTH): vol.All(
@@ -857,7 +827,6 @@ class SelectSchema(KNXPlatformSchema):
                 ],
                 vol.Required(KNX_ADDRESS): ga_list_validator,
                 vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
             }
         ),
         select_options_sub_validator,
@@ -872,18 +841,15 @@ class SensorSchema(KNXPlatformSchema):
     CONF_ALWAYS_CALLBACK = "always_callback"
     CONF_STATE_ADDRESS = CONF_STATE_ADDRESS
     CONF_SYNC_STATE = CONF_SYNC_STATE
-    DEFAULT_NAME = "KNX Sensor"
 
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
             vol.Optional(CONF_ALWAYS_CALLBACK, default=False): cv.boolean,
             vol.Optional(CONF_STATE_CLASS): STATE_CLASSES_SCHEMA,
             vol.Required(CONF_TYPE): sensor_type_validator,
             vol.Required(CONF_STATE_ADDRESS): ga_list_validator,
             vol.Optional(CONF_DEVICE_CLASS): SENSOR_DEVICE_CLASSES_SCHEMA,
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -896,16 +862,13 @@ class SwitchSchema(KNXPlatformSchema):
     CONF_INVERT = CONF_INVERT
     CONF_STATE_ADDRESS = CONF_STATE_ADDRESS
 
-    DEFAULT_NAME = "KNX Switch"
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_INVERT, default=False): cv.boolean,
             vol.Optional(CONF_RESPOND_TO_READ, default=False): cv.boolean,
             vol.Required(KNX_ADDRESS): ga_list_validator,
             vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
             vol.Optional(CONF_DEVICE_CLASS): SWITCH_DEVICE_CLASSES_SCHEMA,
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -915,17 +878,13 @@ class TextSchema(KNXPlatformSchema):
 
     PLATFORM = Platform.TEXT
 
-    DEFAULT_NAME = "KNX Text"
-
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_RESPOND_TO_READ, default=False): cv.boolean,
             vol.Optional(CONF_TYPE, default="latin_1"): string_type_validator,
             vol.Optional(CONF_MODE, default=TextMode.TEXT): vol.Coerce(TextMode),
             vol.Required(KNX_ADDRESS): ga_list_validator,
             vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -935,16 +894,12 @@ class TimeSchema(KNXPlatformSchema):
 
     PLATFORM = Platform.TIME
 
-    DEFAULT_NAME = "KNX Time"
-
-    ENTITY_SCHEMA = vol.Schema(
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
         {
-            vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
             vol.Optional(CONF_RESPOND_TO_READ, default=False): cv.boolean,
             vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
             vol.Required(KNX_ADDRESS): ga_list_validator,
             vol.Optional(CONF_STATE_ADDRESS): ga_list_validator,
-            vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
         }
     )
 
@@ -969,27 +924,21 @@ class WeatherSchema(KNXPlatformSchema):
     CONF_KNX_AIR_PRESSURE_ADDRESS = "address_air_pressure"
     CONF_KNX_HUMIDITY_ADDRESS = "address_humidity"
 
-    DEFAULT_NAME = "KNX Weather Station"
-
-    ENTITY_SCHEMA = vol.All(
-        vol.Schema(
-            {
-                vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-                vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
-                vol.Required(CONF_KNX_TEMPERATURE_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_BRIGHTNESS_SOUTH_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_BRIGHTNESS_EAST_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_BRIGHTNESS_WEST_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_BRIGHTNESS_NORTH_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_WIND_SPEED_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_WIND_BEARING_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_RAIN_ALARM_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_FROST_ALARM_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_WIND_ALARM_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_DAY_NIGHT_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_AIR_PRESSURE_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_KNX_HUMIDITY_ADDRESS): ga_list_validator,
-                vol.Optional(CONF_ENTITY_CATEGORY): ENTITY_CATEGORIES_SCHEMA,
-            }
-        ),
+    ENTITY_SCHEMA = COMMON_ENTITY_SCHEMA.extend(
+        {
+            vol.Optional(CONF_SYNC_STATE, default=True): sync_state_validator,
+            vol.Required(CONF_KNX_TEMPERATURE_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_BRIGHTNESS_SOUTH_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_BRIGHTNESS_EAST_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_BRIGHTNESS_WEST_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_BRIGHTNESS_NORTH_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_WIND_SPEED_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_WIND_BEARING_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_RAIN_ALARM_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_FROST_ALARM_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_WIND_ALARM_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_DAY_NIGHT_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_AIR_PRESSURE_ADDRESS): ga_list_validator,
+            vol.Optional(CONF_KNX_HUMIDITY_ADDRESS): ga_list_validator,
+        }
     )

homeassistant/components/knx/select.py

@@ -49,7 +49,7 @@ def _create_raw_value(xknx: XKNX, config: ConfigType) -> RawValue:
     """Return a KNX RawValue to be used within XKNX."""
     return RawValue(
         xknx,
-        name=config[CONF_NAME],
+        name=config.get(CONF_NAME, ""),
         payload_length=config[CONF_PAYLOAD_LENGTH],
         group_address=config[KNX_ADDRESS],
         group_address_state=config.get(CONF_STATE_ADDRESS),
@@ -65,9 +65,12 @@ class KNXSelect(KnxYamlEntity, SelectEntity, RestoreEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX select."""
+        self._device = _create_raw_value(knx_module.xknx, config)
         super().__init__(
             knx_module=knx_module,
-            device=_create_raw_value(knx_module.xknx, config),
+            unique_id=str(self._device.remote_value.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         self._option_payloads: dict[str, int] = {
             option[SelectSchema.CONF_OPTION]: option[CONF_PAYLOAD]
@@ -75,8 +78,6 @@ class KNXSelect(KnxYamlEntity, SelectEntity, RestoreEntity):
         }
         self._attr_options = list(self._option_payloads)
         self._attr_current_option = None
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.remote_value.group_address)
 
     async def async_added_to_hass(self) -> None:
         """Restore last state."""

homeassistant/components/knx/sensor.py

@@ -200,16 +200,19 @@ class KnxYamlSensor(_KnxSensor, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize of a KNX sensor."""
+        self._device = XknxSensor(
+            knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            group_address_state=config[SensorSchema.CONF_STATE_ADDRESS],
+            sync_state=config[CONF_SYNC_STATE],
+            always_callback=True,
+            value_type=config[CONF_TYPE],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxSensor(
-                knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address_state=config[SensorSchema.CONF_STATE_ADDRESS],
-                sync_state=config[CONF_SYNC_STATE],
-                always_callback=True,
-                value_type=config[CONF_TYPE],
-            ),
+            unique_id=str(self._device.sensor_value.group_address_state),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         if device_class := config.get(CONF_DEVICE_CLASS):
             self._attr_device_class = device_class
@@ -219,8 +222,6 @@ class KnxYamlSensor(_KnxSensor, KnxYamlEntity):
             )
 
         self._attr_force_update = config[SensorSchema.CONF_ALWAYS_CALLBACK]
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.sensor_value.group_address_state)
         self._attr_native_unit_of_measurement = self._device.unit_of_measurement()
         self._attr_state_class = config.get(CONF_STATE_CLASS)
         self._attr_extra_state_attributes = {}

homeassistant/components/knx/switch.py

@@ -107,20 +107,21 @@ class KnxYamlSwitch(_KnxSwitch, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize of KNX switch."""
+        self._device = XknxSwitch(
+            xknx=knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            group_address=config[KNX_ADDRESS],
+            group_address_state=config.get(SwitchSchema.CONF_STATE_ADDRESS),
+            respond_to_read=config[CONF_RESPOND_TO_READ],
+            invert=config[SwitchSchema.CONF_INVERT],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxSwitch(
-                xknx=knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address=config[KNX_ADDRESS],
-                group_address_state=config.get(SwitchSchema.CONF_STATE_ADDRESS),
-                respond_to_read=config[CONF_RESPOND_TO_READ],
-                invert=config[SwitchSchema.CONF_INVERT],
-            ),
+            unique_id=str(self._device.switch.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
         self._attr_device_class = config.get(CONF_DEVICE_CLASS)
-        self._attr_unique_id = str(self._device.switch.group_address)
 
 
 class KnxUiSwitch(_KnxSwitch, KnxUiEntity):

homeassistant/components/knx/text.py

@@ -112,20 +112,21 @@ class KnxYamlText(_KnxText, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX text."""
+        self._device = XknxNotification(
+            knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            group_address=config[KNX_ADDRESS],
+            group_address_state=config.get(CONF_STATE_ADDRESS),
+            respond_to_read=config[CONF_RESPOND_TO_READ],
+            value_type=config[CONF_TYPE],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxNotification(
-                knx_module.xknx,
-                name=config[CONF_NAME],
-                group_address=config[KNX_ADDRESS],
-                group_address_state=config.get(CONF_STATE_ADDRESS),
-                respond_to_read=config[CONF_RESPOND_TO_READ],
-                value_type=config[CONF_TYPE],
-            ),
+            unique_id=str(self._device.remote_value.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
         self._attr_mode = config[CONF_MODE]
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.remote_value.group_address)
 
 
 class KnxUiText(_KnxText, KnxUiEntity):

homeassistant/components/knx/time.py

@@ -105,20 +105,21 @@ class KnxYamlTime(_KNXTime, KnxYamlEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize a KNX time."""
+        self._device = XknxTimeDevice(
+            knx_module.xknx,
+            name=config.get(CONF_NAME, ""),
+            localtime=False,
+            group_address=config[KNX_ADDRESS],
+            group_address_state=config.get(CONF_STATE_ADDRESS),
+            respond_to_read=config[CONF_RESPOND_TO_READ],
+            sync_state=config[CONF_SYNC_STATE],
+        )
         super().__init__(
             knx_module=knx_module,
-            device=XknxTimeDevice(
-                knx_module.xknx,
-                name=config[CONF_NAME],
-                localtime=False,
-                group_address=config[KNX_ADDRESS],
-                group_address_state=config.get(CONF_STATE_ADDRESS),
-                respond_to_read=config[CONF_RESPOND_TO_READ],
-                sync_state=config[CONF_SYNC_STATE],
-            ),
+            unique_id=str(self._device.remote_value.group_address),
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
-        self._attr_unique_id = str(self._device.remote_value.group_address)
 
 
 class KnxUiTime(_KNXTime, KnxUiEntity):

homeassistant/components/knx/weather.py

@@ -43,7 +43,7 @@ def _create_weather(xknx: XKNX, config: ConfigType) -> XknxWeather:
     """Return a KNX weather device to be used within XKNX."""
     return XknxWeather(
         xknx,
-        name=config[CONF_NAME],
+        name=config.get(CONF_NAME, ""),
         sync_state=config[WeatherSchema.CONF_SYNC_STATE],
         group_address_temperature=config[WeatherSchema.CONF_KNX_TEMPERATURE_ADDRESS],
         group_address_brightness_south=config.get(
@@ -85,12 +85,13 @@ class KNXWeather(KnxYamlEntity, WeatherEntity):
 
     def __init__(self, knx_module: KNXModule, config: ConfigType) -> None:
         """Initialize of a KNX sensor."""
+        self._device = _create_weather(knx_module.xknx, config)
         super().__init__(
             knx_module=knx_module,
-            device=_create_weather(knx_module.xknx, config),
+            unique_id=str(self._device._temperature.group_address_state),  # noqa: SLF001
+            name=config.get(CONF_NAME),
+            entity_category=config.get(CONF_ENTITY_CATEGORY),
         )
-        self._attr_unique_id = str(self._device._temperature.group_address_state)  # noqa: SLF001
-        self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
 
     @property
     def native_temperature(self) -> float | None:

homeassistant/components/libre_hardware_monitor/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["librehardwaremonitor-api==1.8.4"]
+  "requirements": ["librehardwaremonitor-api==1.7.2"]
 }

homeassistant/components/matter/climate.py

@@ -154,7 +154,6 @@ SUPPORT_FAN_MODE_DEVICES: set[tuple[int, int]] = {
     (0x1209, 0x8027),
     (0x1209, 0x8028),
     (0x1209, 0x8029),
-    (0x131A, 0x1000),
 }
 
 SystemModeEnum = clusters.Thermostat.Enums.SystemModeEnum

homeassistant/components/mobile_app/http_api.py

@@ -69,7 +69,7 @@ class RegistrationsView(HomeAssistantView):
 
         webhook_id = secrets.token_hex()
 
-        if cloud.async_active_subscription(hass) and cloud.async_is_connected(hass):
+        if cloud.async_active_subscription(hass):
             data[CONF_CLOUDHOOK_URL] = await async_create_cloud_hook(
                 hass, webhook_id, None
             )

homeassistant/components/openevse/__init__.py

@@ -1,30 +1 @@
-"""The OpenEVSE integration."""
-
-from __future__ import annotations
-
-import openevsewifi
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_HOST, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError
-
-type OpenEVSEConfigEntry = ConfigEntry[openevsewifi.Charger]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: OpenEVSEConfigEntry) -> bool:
-    """Set up openevse from a config entry."""
-
-    entry.runtime_data = openevsewifi.Charger(entry.data[CONF_HOST])
-    try:
-        await hass.async_add_executor_job(entry.runtime_data.getStatus)
-    except AttributeError as ex:
-        raise ConfigEntryError("Unable to connect to charger") from ex
-
-    await hass.config_entries.async_forward_entry_setups(entry, [Platform.SENSOR])
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, [Platform.SENSOR])
+"""The openevse component."""

homeassistant/components/openevse/config_flow.py

@@ -1,64 +0,0 @@
-"""Config flow for OpenEVSE integration."""
-
-from typing import Any
-
-import openevsewifi
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST
-
-from .const import DOMAIN
-
-
-class OpenEVSEConfigFlow(ConfigFlow, domain=DOMAIN):
-    """OpenEVSE config flow."""
-
-    VERSION = 1
-    MINOR_VERSION = 1
-
-    async def check_status(self, host: str) -> bool:
-        """Check if we can connect to the OpenEVSE charger."""
-
-        charger = openevsewifi.Charger(host)
-        try:
-            result = await self.hass.async_add_executor_job(charger.getStatus)
-        except AttributeError:
-            return False
-        else:
-            return result is not None
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-
-        errors = None
-        if user_input is not None:
-            self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
-
-            if await self.check_status(user_input[CONF_HOST]):
-                return self.async_create_entry(
-                    title=f"OpenEVSE {user_input[CONF_HOST]}",
-                    data=user_input,
-                )
-            errors = {CONF_HOST: "cannot_connect"}
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema({vol.Required(CONF_HOST): str}),
-            errors=errors,
-        )
-
-    async def async_step_import(self, data: dict[str, str]) -> ConfigFlowResult:
-        """Handle the initial step."""
-
-        self._async_abort_entries_match({CONF_HOST: data[CONF_HOST]})
-
-        if not await self.check_status(data[CONF_HOST]):
-            return self.async_abort(reason="unavailable_host")
-
-        return self.async_create_entry(
-            title=f"OpenEVSE {data[CONF_HOST]}",
-            data=data,
-        )

homeassistant/components/openevse/const.py

@@ -1,4 +0,0 @@
-"""Constants for the OpenEVSE integration."""
-
-DOMAIN = "openevse"
-INTEGRATION_TITLE = "OpenEVSE"

homeassistant/components/openevse/manifest.json

@@ -1,10 +1,8 @@
 {
   "domain": "openevse",
   "name": "OpenEVSE",
-  "codeowners": ["@c00w"],
-  "config_flow": true,
+  "codeowners": [],
   "documentation": "https://www.home-assistant.io/integrations/openevse",
-  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["openevsewifi"],
   "quality_scale": "legacy",

homeassistant/components/openevse/sensor.py

@@ -9,14 +9,12 @@ from requests import RequestException
 import voluptuous as vol
 
 from homeassistant.components.sensor import (
-    DOMAIN as HOMEASSISTANT_DOMAIN,
     PLATFORM_SCHEMA as SENSOR_PLATFORM_SCHEMA,
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import (
     CONF_HOST,
     CONF_MONITORED_VARIABLES,
@@ -25,17 +23,10 @@ from homeassistant.const import (
     UnitOfTime,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.data_entry_flow import FlowResultType
-from homeassistant.helpers import config_validation as cv, issue_registry as ir
-from homeassistant.helpers.entity_platform import (
-    AddConfigEntryEntitiesCallback,
-    AddEntitiesCallback,
-)
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
-from . import ConfigEntry
-from .const import DOMAIN, INTEGRATION_TITLE
-
 _LOGGER = logging.getLogger(__name__)
 
 SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
@@ -63,7 +54,6 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
         key="rtc_temp",
@@ -71,7 +61,6 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        entity_registry_enabled_default=False,
     ),
     SensorEntityDescription(
         key="usage_session",
@@ -101,86 +90,33 @@ PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
 )
 
 
-async def async_setup_platform(
+def setup_platform(
     hass: HomeAssistant,
     config: ConfigType,
-    async_add_entities: AddEntitiesCallback,
+    add_entities: AddEntitiesCallback,
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
-    """Set up the openevse platform."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": SOURCE_IMPORT},
-        data=config,
-    )
+    """Set up the OpenEVSE sensor."""
+    host = config[CONF_HOST]
+    monitored_variables = config[CONF_MONITORED_VARIABLES]
 
-    if (
-        result.get("type") is FlowResultType.ABORT
-        and result.get("reason") != "already_configured"
-    ):
-        ir.async_create_issue(
-            hass,
-            DOMAIN,
-            f"deprecated_yaml_import_issue_{result.get('reason')}",
-            breaks_in_ha_version="2026.6.0",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key=f"deprecated_yaml_import_issue_{result.get('reason')}",
-            translation_placeholders={
-                "domain": DOMAIN,
-                "integration_title": INTEGRATION_TITLE,
-            },
-        )
-        return
+    charger = openevsewifi.Charger(host)
 
-    ir.async_create_issue(
-        hass,
-        HOMEASSISTANT_DOMAIN,
-        "deprecated_yaml",
-        breaks_in_ha_version="2026.7.0",
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        severity=ir.IssueSeverity.WARNING,
-        translation_key="deprecated_yaml",
-        translation_placeholders={
-            "domain": DOMAIN,
-            "integration_title": INTEGRATION_TITLE,
-        },
-    )
+    entities = [
+        OpenEVSESensor(charger, description)
+        for description in SENSOR_TYPES
+        if description.key in monitored_variables
+    ]
 
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Add sensors for passed config_entry in HA."""
-    async_add_entities(
-        (
-            OpenEVSESensor(
-                config_entry.data[CONF_HOST],
-                config_entry.runtime_data,
-                description,
-            )
-            for description in SENSOR_TYPES
-        ),
-        True,
-    )
+    add_entities(entities, True)
 
 
 class OpenEVSESensor(SensorEntity):
     """Implementation of an OpenEVSE sensor."""
 
-    def __init__(
-        self,
-        host: str,
-        charger: openevsewifi.Charger,
-        description: SensorEntityDescription,
-    ) -> None:
+    def __init__(self, charger, description: SensorEntityDescription) -> None:
         """Initialize the sensor."""
         self.entity_description = description
-        self.host = host
         self.charger = charger
 
     def update(self) -> None:

homeassistant/components/openevse/strings.json

@@ -1,27 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "This charger is already configured",
-      "unavailable_host": "Unable to connect to host"
-    },
-    "error": {
-      "cannot_connect": "Unable to connect"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]"
-        },
-        "data_description": {
-          "host": "Enter the IP Address of your openevse. Should match the address you used to set it up."
-        }
-      }
-    }
-  },
-  "issues": {
-    "yaml_deprecated": {
-      "description": "Configuring OpenEVSE using YAML is being removed. Your existing YAML configuration has been imported into the UI automatically. Remove the `openevse` configuration from your configuration.yaml file and restart Home Assistant to fix this issue.",
-      "title": "OpenEVSE YAML configuration is deprecated"
-    }
-  }
-}

homeassistant/components/opower/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
   "quality_scale": "bronze",
-  "requirements": ["opower==0.16.0"]
+  "requirements": ["opower==0.15.9"]
 }

homeassistant/components/person/icons.json

@@ -11,13 +11,5 @@
     "reload": {
       "service": "mdi:reload"
     }
-  },
-  "triggers": {
-    "entered_home": {
-      "trigger": "mdi:account-arrow-left"
-    },
-    "left_home": {
-      "trigger": "mdi:account-arrow-right"
-    }
   }
 }

homeassistant/components/person/strings.json

@@ -1,8 +1,4 @@
 {
-  "common": {
-    "trigger_behavior_description": "The behavior of the targeted persons to trigger on.",
-    "trigger_behavior_name": "Behavior"
-  },
   "entity_component": {
     "_": {
       "name": "[%key:component::person::title%]",
@@ -29,42 +25,11 @@
       }
     }
   },
-  "selector": {
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
-    }
-  },
   "services": {
     "reload": {
       "description": "Reloads persons from the YAML-configuration.",
       "name": "[%key:common::action::reload%]"
     }
   },
-  "title": "Person",
-  "triggers": {
-    "entered_home": {
-      "description": "Triggers when one or more persons enter home.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::person::common::trigger_behavior_description%]",
-          "name": "[%key:component::person::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Entered home"
-    },
-    "left_home": {
-      "description": "Triggers when one or more persons leave home.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::person::common::trigger_behavior_description%]",
-          "name": "[%key:component::person::common::trigger_behavior_name%]"
-        }
-      },
-      "name": "Left home"
-    }
-  }
+  "title": "Person"
 }

homeassistant/components/person/trigger.py

@@ -1,21 +0,0 @@
-"""Provides triggers for persons."""
-
-from homeassistant.const import STATE_HOME
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.trigger import (
-    Trigger,
-    make_entity_origin_state_trigger,
-    make_entity_target_state_trigger,
-)
-
-from .const import DOMAIN
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "entered_home": make_entity_target_state_trigger(DOMAIN, STATE_HOME),
-    "left_home": make_entity_origin_state_trigger(DOMAIN, from_state=STATE_HOME),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for persons."""
-    return TRIGGERS

homeassistant/components/person/triggers.yaml

@@ -1,18 +0,0 @@
-.trigger_common: &trigger_common
-  target:
-    entity:
-      domain: person
-  fields:
-    behavior:
-      required: true
-      default: any
-      selector:
-        select:
-          options:
-            - first
-            - last
-            - any
-          translation_key: trigger_behavior
-
-entered_home: *trigger_common
-left_home: *trigger_common

homeassistant/components/remote_calendar/config_flow.py

@@ -8,7 +8,7 @@ from httpx import HTTPError, InvalidURL, TimeoutException
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_URL, CONF_VERIFY_SSL
+from homeassistant.const import CONF_URL
 from homeassistant.helpers.httpx_client import get_async_client
 
 from .client import get_calendar
@@ -21,7 +21,6 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_CALENDAR_NAME): str,
         vol.Required(CONF_URL): str,
-        vol.Required(CONF_VERIFY_SSL, default=True): bool,
     }
 )
 
@@ -49,7 +48,7 @@ class RemoteCalendarConfigFlow(ConfigFlow, domain=DOMAIN):
                 "webcal://", "https://", 1
             )
         self._async_abort_entries_match({CONF_URL: user_input[CONF_URL]})
-        client = get_async_client(self.hass, verify_ssl=user_input[CONF_VERIFY_SSL])
+        client = get_async_client(self.hass)
         try:
             res = await get_calendar(client, user_input[CONF_URL])
             if res.status_code == HTTPStatus.FORBIDDEN:

homeassistant/components/remote_calendar/coordinator.py

@@ -7,7 +7,7 @@ from httpx import HTTPError, InvalidURL, TimeoutException
 from ical.calendar import Calendar
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_URL, CONF_VERIFY_SSL
+from homeassistant.const import CONF_URL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
@@ -42,9 +42,7 @@ class RemoteCalendarDataUpdateCoordinator(DataUpdateCoordinator[Calendar]):
             config_entry=config_entry,
             always_update=True,
         )
-        self._client = get_async_client(
-            hass, verify_ssl=config_entry.data.get(CONF_VERIFY_SSL, True)
-        )
+        self._client = get_async_client(hass)
         self._url = config_entry.data[CONF_URL]
 
     async def _async_update_data(self) -> Calendar:

homeassistant/components/remote_calendar/strings.json

@@ -13,13 +13,11 @@
       "user": {
         "data": {
           "calendar_name": "Calendar name",
-          "url": "Calendar URL",
-          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+          "url": "Calendar URL"
         },
         "data_description": {
           "calendar_name": "The name of the calendar shown in the UI.",
-          "url": "The URL of the remote calendar.",
-          "verify_ssl": "Enable SSL certificate verification for secure connections."
+          "url": "The URL of the remote calendar."
         },
         "description": "Please choose a name for the calendar to be imported"
       }

homeassistant/components/roborock/manifest.json

@@ -20,7 +20,7 @@
   "loggers": ["roborock"],
   "quality_scale": "silver",
   "requirements": [
-    "python-roborock==4.2.0",
+    "python-roborock==4.1.0",
     "vacuum-map-parser-roborock==0.1.4"
   ]
 }

homeassistant/components/samsungtv/manifest.json

@@ -40,7 +40,7 @@
     "samsungctl[websocket]==0.7.1",
     "samsungtvws[async,encrypted]==2.7.2",
     "wakeonlan==3.1.0",
-    "async-upnp-client==0.46.2"
+    "async-upnp-client==0.46.1"
   ],
   "ssdp": [
     {

homeassistant/components/saunum/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pysaunum"],
-  "quality_scale": "gold",
+  "quality_scale": "silver",
   "requirements": ["pysaunum==0.1.0"]
 }

homeassistant/components/saunum/quality_scale.yaml

@@ -49,7 +49,7 @@ rules:
     status: exempt
     comment: Device cannot be discovered and the Modbus TCP API does not provide MAC address or other unique network identifiers needed to update connection information.
   docs-data-update: done
-  docs-examples: done
+  docs-examples: todo
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done

homeassistant/components/solaredge/sensor.py

@@ -46,7 +46,7 @@ SENSOR_TYPES = [
         key="lifetime_energy",
         json_key="lifeTimeData",
         translation_key="lifetime_energy",
-        state_class=SensorStateClass.TOTAL_INCREASING,
+        state_class=SensorStateClass.TOTAL,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
     ),
@@ -55,7 +55,6 @@ SENSOR_TYPES = [
         json_key="lastYearData",
         translation_key="energy_this_year",
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
     ),
@@ -64,7 +63,6 @@ SENSOR_TYPES = [
         json_key="lastMonthData",
         translation_key="energy_this_month",
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
     ),
@@ -73,7 +71,6 @@ SENSOR_TYPES = [
         json_key="lastDayData",
         translation_key="energy_today",
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
     ),
@@ -126,32 +123,24 @@ SENSOR_TYPES = [
         json_key="LOAD",
         translation_key="power_consumption",
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
     ),
     SolarEdgeSensorEntityDescription(
         key="solar_power",
         json_key="PV",
         translation_key="solar_power",
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
     ),
     SolarEdgeSensorEntityDescription(
         key="grid_power",
         json_key="GRID",
         translation_key="grid_power",
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
     ),
     SolarEdgeSensorEntityDescription(
         key="storage_power",
         json_key="STORAGE",
         translation_key="storage_power",
         entity_registry_enabled_default=False,
-        state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.POWER,
     ),
     SolarEdgeSensorEntityDescription(
         key="purchased_energy",
@@ -205,7 +194,6 @@ SENSOR_TYPES = [
         entity_registry_enabled_default=False,
         state_class=SensorStateClass.MEASUREMENT,
         native_unit_of_measurement=PERCENTAGE,
-        device_class=SensorDeviceClass.BATTERY,
     ),
 ]
 

homeassistant/components/ssdp/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_push",
   "loggers": ["async_upnp_client"],
   "quality_scale": "internal",
-  "requirements": ["async-upnp-client==0.46.2"]
+  "requirements": ["async-upnp-client==0.46.1"]
 }

homeassistant/components/switchbot_cloud/__init__.py

@@ -280,9 +280,6 @@ async def make_device_data(
         "RGBICWW Strip Light",
         "Ceiling Light",
         "Ceiling Light Pro",
-        "RGBIC Neon Rope Light",
-        "RGBIC Neon Wire Rope Light",
-        "Candle Warmer Lamp",
     ]:
         coordinator = await coordinator_for_device(
             hass, entry, api, device, coordinators_by_id

homeassistant/components/switchbot_cloud/light.py

@@ -132,46 +132,15 @@ class SwitchBotCloudLight(SwitchBotCloudEntity, LightEntity):
         )
 
 
-class SwitchBotCloudCandleWarmerLamp(SwitchBotCloudLight):
-    """Representation of a SwitchBotCloud CandleWarmerLamp."""
-
-    # Brightness adjustment
-
-    _attr_supported_color_modes = {ColorMode.BRIGHTNESS}
-
-
 class SwitchBotCloudStripLight(SwitchBotCloudLight):
     """Representation of a SwitchBot Strip Light."""
 
-    # Brightness adjustment
-    # RGB color control
-
     _attr_supported_color_modes = {ColorMode.RGB}
 
 
-class SwitchBotCloudRGBICLight(SwitchBotCloudLight):
-    """Representation of a SwitchBotCloudRGBICLight."""
-
-    # Brightness adjustment
-    # RGB color control
-
-    _attr_supported_color_modes = {ColorMode.RGB}
-
-    async def _send_rgb_color_command(self, rgb_color: tuple) -> None:
-        """Send an RGB command."""
-        await self.send_api_command(
-            RGBWLightCommands.SET_COLOR,
-            parameters=f"{rgb_color[0]}:{rgb_color[1]}:{rgb_color[2]}",
-        )
-
-
 class SwitchBotCloudRGBWWLight(SwitchBotCloudLight):
     """Representation of SwitchBot |Strip Light|Floor Lamp|Color Bulb."""
 
-    # Brightness adjustment
-    # RGB color control
-    # Color temperature control
-
     _attr_max_color_temp_kelvin = 6500
     _attr_min_color_temp_kelvin = 2700
 
@@ -195,9 +164,6 @@ class SwitchBotCloudRGBWWLight(SwitchBotCloudLight):
 class SwitchBotCloudCeilingLight(SwitchBotCloudLight):
     """Representation of SwitchBot Ceiling Light."""
 
-    # Brightness adjustment
-    # Color temperature control
-
     _attr_max_color_temp_kelvin = 6500
     _attr_min_color_temp_kelvin = 2700
 
@@ -221,14 +187,10 @@ class SwitchBotCloudCeilingLight(SwitchBotCloudLight):
 @callback
 def _async_make_entity(
     api: SwitchBotAPI, device: Device | Remote, coordinator: SwitchBotCoordinator
-) -> SwitchBotCloudLight:
+) -> SwitchBotCloudStripLight | SwitchBotCloudRGBWWLight | SwitchBotCloudCeilingLight:
     """Make a SwitchBotCloudLight."""
     if device.device_type == "Strip Light":
         return SwitchBotCloudStripLight(api, device, coordinator)
     if device.device_type in ["Ceiling Light", "Ceiling Light Pro"]:
         return SwitchBotCloudCeilingLight(api, device, coordinator)
-    if device.device_type == "Candle Warmer Lamp":
-        return SwitchBotCloudCandleWarmerLamp(api, device, coordinator)
-    if device.device_type in ["RGBIC Neon Rope Light", "RGBIC Neon Wire Rope Light"]:
-        return SwitchBotCloudRGBICLight(api, device, coordinator)
     return SwitchBotCloudRGBWWLight(api, device, coordinator)

homeassistant/components/system_bridge/manifest.json

@@ -9,6 +9,6 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["systembridgeconnector"],
-  "requirements": ["systembridgeconnector==5.3.1"],
+  "requirements": ["systembridgeconnector==5.2.4"],
   "zeroconf": ["_system-bridge._tcp.local."]
 }

homeassistant/components/tesla_fleet/update.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import time
 from typing import Any
 
 from tesla_fleet_api.const import Scope
@@ -25,9 +24,6 @@ SCHEDULED = "scheduled"
 
 PARALLEL_UPDATES = 0
 
-# Show scheduled update as installing if within this many seconds
-SCHEDULED_THRESHOLD_SECONDS = 120
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -73,9 +69,12 @@ class TeslaFleetUpdateEntity(TeslaFleetVehicleEntity, UpdateEntity):
     def _async_update_attrs(self) -> None:
         """Update the attributes of the entity."""
 
-        # Supported Features - only show install button if update is available
-        # but not already scheduled
-        if self.scoped and self._value == AVAILABLE:
+        # Supported Features
+        if self.scoped and self._value in (
+            AVAILABLE,
+            SCHEDULED,
+        ):
+            # Only allow install when an update has been fully downloaded
             self._attr_supported_features = (
                 UpdateEntityFeature.PROGRESS | UpdateEntityFeature.INSTALL
             )
@@ -88,9 +87,13 @@ class TeslaFleetUpdateEntity(TeslaFleetVehicleEntity, UpdateEntity):
             # Remove build from version
             self._attr_installed_version = self._attr_installed_version.split(" ")[0]
 
-        # Latest Version - hide update if scheduled far in the future
-        if self._value in (AVAILABLE, INSTALLING, DOWNLOADING, WIFI_WAIT) or (
-            self._value == SCHEDULED and self._is_scheduled_soon()
+        # Latest Version
+        if self._value in (
+            AVAILABLE,
+            SCHEDULED,
+            INSTALLING,
+            DOWNLOADING,
+            WIFI_WAIT,
         ):
             self._attr_latest_version = self.coordinator.data[
                 "vehicle_state_software_update_version"
@@ -98,24 +101,14 @@ class TeslaFleetUpdateEntity(TeslaFleetVehicleEntity, UpdateEntity):
         else:
             self._attr_latest_version = self._attr_installed_version
 
-        # In Progress - only show as installing if actually installing or
-        # scheduled to start within 2 minutes
-        if self._value == INSTALLING:
+        # In Progress
+        if self._value in (
+            SCHEDULED,
+            INSTALLING,
+        ):
             self._attr_in_progress = True
             if install_perc := self.get("vehicle_state_software_update_install_perc"):
                 self._attr_update_percentage = install_perc
-        elif self._value == SCHEDULED and self._is_scheduled_soon():
-            self._attr_in_progress = True
-            self._attr_update_percentage = None
         else:
             self._attr_in_progress = False
             self._attr_update_percentage = None
-
-    def _is_scheduled_soon(self) -> bool:
-        """Check if a scheduled update is within the threshold to start."""
-        scheduled_time_ms = self.get("vehicle_state_software_update_scheduled_time_ms")
-        if scheduled_time_ms is None:
-            return False
-        # Convert milliseconds to seconds and compare to current time
-        scheduled_time_sec = scheduled_time_ms / 1000
-        return scheduled_time_sec - time.time() < SCHEDULED_THRESHOLD_SECONDS

homeassistant/components/tibber/__init__.py

@@ -1,36 +1,20 @@
 """Support for Tibber."""
 
-from __future__ import annotations
-
-from dataclasses import dataclass, field
 import logging
 
 import aiohttp
-from aiohttp.client_exceptions import ClientError, ClientResponseError
 import tibber
-from tibber import data_api as tibber_data_api
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ACCESS_TOKEN, EVENT_HOMEASSISTANT_STOP, Platform
 from homeassistant.core import Event, HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-    OAuth2Session,
-    async_get_config_entry_implementation,
-)
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util, ssl as ssl_util
 
-from .const import (
-    AUTH_IMPLEMENTATION,
-    CONF_LEGACY_ACCESS_TOKEN,
-    DATA_HASS_CONFIG,
-    DOMAIN,
-    TibberConfigEntry,
-)
-from .coordinator import TibberDataAPICoordinator
+from .const import DATA_HASS_CONFIG, DOMAIN
 from .services import async_setup_services
 
 PLATFORMS = [Platform.NOTIFY, Platform.SENSOR]
@@ -40,33 +24,6 @@ CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 _LOGGER = logging.getLogger(__name__)
 
 
-@dataclass
-class TibberRuntimeData:
-    """Runtime data for Tibber API entries."""
-
-    tibber_connection: tibber.Tibber
-    session: OAuth2Session
-    data_api_coordinator: TibberDataAPICoordinator | None = field(default=None)
-    _client: tibber_data_api.TibberDataAPI | None = None
-
-    async def async_get_client(
-        self, hass: HomeAssistant
-    ) -> tibber_data_api.TibberDataAPI:
-        """Return an authenticated Tibber Data API client."""
-        await self.session.async_ensure_token_valid()
-        token = self.session.token
-        access_token = token.get(CONF_ACCESS_TOKEN)
-        if not access_token:
-            raise ConfigEntryAuthFailed("Access token missing from OAuth session")
-        if self._client is None:
-            self._client = tibber_data_api.TibberDataAPI(
-                access_token,
-                websession=async_get_clientsession(hass),
-            )
-        self._client.set_access_token(access_token)
-        return self._client
-
-
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Tibber component."""
 
@@ -77,23 +34,16 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: TibberConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a config entry."""
 
-    # Added in 2026.1 to migrate existing users to OAuth2 (Tibber Data API).
-    # Can be removed after 2026.7
-    if AUTH_IMPLEMENTATION not in entry.data:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="data_api_reauth_required",
-        )
-
     tibber_connection = tibber.Tibber(
-        access_token=entry.data[CONF_LEGACY_ACCESS_TOKEN],
+        access_token=entry.data[CONF_ACCESS_TOKEN],
         websession=async_get_clientsession(hass),
         time_zone=dt_util.get_default_time_zone(),
         ssl=ssl_util.get_default_context(),
     )
+    hass.data[DOMAIN] = tibber_connection
 
     async def _close(event: Event) -> None:
         await tibber_connection.rt_disconnect()
@@ -102,6 +52,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: TibberConfigEntry) -> bo
 
     try:
         await tibber_connection.update_info()
+
     except (
         TimeoutError,
         aiohttp.ClientError,
@@ -114,45 +65,17 @@ async def async_setup_entry(hass: HomeAssistant, entry: TibberConfigEntry) -> bo
     except tibber.FatalHttpExceptionError:
         return False
 
-    try:
-        implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
-
-    session = OAuth2Session(hass, entry, implementation)
-    try:
-        await session.async_ensure_token_valid()
-    except ClientResponseError as err:
-        if 400 <= err.status < 500:
-            raise ConfigEntryAuthFailed(
-                "OAuth session is not valid, reauthentication required"
-            ) from err
-        raise ConfigEntryNotReady from err
-    except ClientError as err:
-        raise ConfigEntryNotReady from err
-
-    entry.runtime_data = TibberRuntimeData(
-        tibber_connection=tibber_connection,
-        session=session,
-    )
-
-    coordinator = TibberDataAPICoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data.data_api_coordinator = coordinator
-
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
     return True
 
 
-async def async_unload_entry(
-    hass: HomeAssistant, config_entry: TibberConfigEntry
-) -> bool:
+async def async_unload_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(
+    unload_ok = await hass.config_entries.async_unload_platforms(
         config_entry, PLATFORMS
-    ):
-        await config_entry.runtime_data.tibber_connection.rt_disconnect()
+    )
+    if unload_ok:
+        tibber_connection = hass.data[DOMAIN]
+        await tibber_connection.rt_disconnect()
     return unload_ok

homeassistant/components/tibber/application_credentials.py

@@ -1,15 +0,0 @@
-"""Application credentials platform for Tibber."""
-
-from homeassistant.components.application_credentials import AuthorizationServer
-from homeassistant.core import HomeAssistant
-
-AUTHORIZE_URL = "https://thewall.tibber.com/connect/authorize"
-TOKEN_URL = "https://thewall.tibber.com/connect/token"
-
-
-async def async_get_authorization_server(hass: HomeAssistant) -> AuthorizationServer:
-    """Return authorization server for Tibber Data API."""
-    return AuthorizationServer(
-        authorize_url=AUTHORIZE_URL,
-        token_url=TOKEN_URL,
-    )

homeassistant/components/tibber/config_flow.py

@@ -2,164 +2,80 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
-import logging
 from typing import Any
 
 import aiohttp
 import tibber
-from tibber import data_api as tibber_data_api
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_REAUTH, SOURCE_USER, ConfigFlowResult
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
 
-from .const import CONF_LEGACY_ACCESS_TOKEN, DATA_API_DEFAULT_SCOPES, DOMAIN
+from .const import DOMAIN
 
-DATA_SCHEMA = vol.Schema({vol.Required(CONF_LEGACY_ACCESS_TOKEN): str})
+DATA_SCHEMA = vol.Schema({vol.Required(CONF_ACCESS_TOKEN): str})
 ERR_TIMEOUT = "timeout"
 ERR_CLIENT = "cannot_connect"
 ERR_TOKEN = "invalid_access_token"
 TOKEN_URL = "https://developer.tibber.com/settings/access-token"
 
-_LOGGER = logging.getLogger(__name__)
 
-
-class TibberConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
+class TibberConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Tibber integration."""
 
     VERSION = 1
-    DOMAIN = DOMAIN
-
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        super().__init__()
-        self._access_token: str | None = None
-        self._title = ""
-
-    @property
-    def logger(self) -> logging.Logger:
-        """Return the logger."""
-        return _LOGGER
-
-    @property
-    def extra_authorize_data(self) -> dict[str, Any]:
-        """Extra data appended to the authorize URL."""
-        return {
-            **super().extra_authorize_data,
-            "scope": " ".join(DATA_API_DEFAULT_SCOPES),
-        }
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
-        if user_input is None:
-            data_schema = self.add_suggested_values_to_schema(
-                DATA_SCHEMA, {CONF_LEGACY_ACCESS_TOKEN: self._access_token or ""}
+
+        self._async_abort_entries_match()
+
+        if user_input is not None:
+            access_token = user_input[CONF_ACCESS_TOKEN].replace(" ", "")
+
+            tibber_connection = tibber.Tibber(
+                access_token=access_token,
+                websession=async_get_clientsession(self.hass),
             )
 
-            return self.async_show_form(
-                step_id=SOURCE_USER,
-                data_schema=data_schema,
-                description_placeholders={"url": TOKEN_URL},
-                errors={},
-            )
+            errors = {}
 
-        self._access_token = user_input[CONF_LEGACY_ACCESS_TOKEN].replace(" ", "")
-        tibber_connection = tibber.Tibber(
-            access_token=self._access_token,
-            websession=async_get_clientsession(self.hass),
-        )
-        self._title = tibber_connection.name or "Tibber"
+            try:
+                await tibber_connection.update_info()
+            except TimeoutError:
+                errors[CONF_ACCESS_TOKEN] = ERR_TIMEOUT
+            except tibber.InvalidLoginError:
+                errors[CONF_ACCESS_TOKEN] = ERR_TOKEN
+            except (
+                aiohttp.ClientError,
+                tibber.RetryableHttpExceptionError,
+                tibber.FatalHttpExceptionError,
+            ):
+                errors[CONF_ACCESS_TOKEN] = ERR_CLIENT
 
-        errors: dict[str, str] = {}
-        try:
-            await tibber_connection.update_info()
-        except TimeoutError:
-            errors[CONF_LEGACY_ACCESS_TOKEN] = ERR_TIMEOUT
-        except tibber.InvalidLoginError:
-            errors[CONF_LEGACY_ACCESS_TOKEN] = ERR_TOKEN
-        except (
-            aiohttp.ClientError,
-            tibber.RetryableHttpExceptionError,
-            tibber.FatalHttpExceptionError,
-        ):
-            errors[CONF_LEGACY_ACCESS_TOKEN] = ERR_CLIENT
+            if errors:
+                return self.async_show_form(
+                    step_id="user",
+                    data_schema=DATA_SCHEMA,
+                    description_placeholders={"url": TOKEN_URL},
+                    errors=errors,
+                )
 
-        if errors:
-            data_schema = self.add_suggested_values_to_schema(
-                DATA_SCHEMA, {CONF_LEGACY_ACCESS_TOKEN: self._access_token or ""}
-            )
-
-            return self.async_show_form(
-                step_id=SOURCE_USER,
-                data_schema=data_schema,
-                description_placeholders={"url": TOKEN_URL},
-                errors=errors,
-            )
-
-        await self.async_set_unique_id(tibber_connection.user_id)
-
-        if self.source == SOURCE_REAUTH:
-            reauth_entry = self._get_reauth_entry()
-            self._abort_if_unique_id_mismatch(
-                reason="wrong_account",
-                description_placeholders={"title": reauth_entry.title},
-            )
-        else:
+            unique_id = tibber_connection.user_id
+            await self.async_set_unique_id(unique_id)
             self._abort_if_unique_id_configured()
 
-        return await self.async_step_pick_implementation()
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle a reauth flow."""
-        reauth_entry = self._get_reauth_entry()
-        self._access_token = reauth_entry.data.get(CONF_LEGACY_ACCESS_TOKEN)
-        self._title = reauth_entry.title
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Confirm reauthentication by reusing the user step."""
-        reauth_entry = self._get_reauth_entry()
-        self._access_token = reauth_entry.data.get(CONF_LEGACY_ACCESS_TOKEN)
-        self._title = reauth_entry.title
-        if user_input is None:
-            return self.async_show_form(
-                step_id="reauth_confirm",
+            return self.async_create_entry(
+                title=tibber_connection.name,
+                data={CONF_ACCESS_TOKEN: access_token},
             )
-        return await self.async_step_user()
 
-    async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
-        """Finalize the OAuth flow and create the config entry."""
-        if self._access_token is None:
-            return self.async_abort(reason="missing_configuration")
-
-        data[CONF_LEGACY_ACCESS_TOKEN] = self._access_token
-
-        access_token = data[CONF_TOKEN][CONF_ACCESS_TOKEN]
-        data_api_client = tibber_data_api.TibberDataAPI(
-            access_token,
-            websession=async_get_clientsession(self.hass),
+        return self.async_show_form(
+            step_id="user",
+            data_schema=DATA_SCHEMA,
+            description_placeholders={"url": TOKEN_URL},
+            errors={},
         )
-
-        try:
-            await data_api_client.get_userinfo()
-        except (aiohttp.ClientError, TimeoutError):
-            return self.async_abort(reason="cannot_connect")
-
-        if self.source == SOURCE_REAUTH:
-            reauth_entry = self._get_reauth_entry()
-            return self.async_update_reload_and_abort(
-                reauth_entry,
-                data=data,
-                title=self._title,
-            )
-
-        return self.async_create_entry(title=self._title, data=data)

homeassistant/components/tibber/const.py

@@ -1,34 +1,5 @@
 """Constants for Tibber integration."""
 
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_ACCESS_TOKEN
-
-if TYPE_CHECKING:
-    from . import TibberRuntimeData
-
-type TibberConfigEntry = ConfigEntry[TibberRuntimeData]
-
-
-CONF_LEGACY_ACCESS_TOKEN = CONF_ACCESS_TOKEN
-
-AUTH_IMPLEMENTATION = "auth_implementation"
 DATA_HASS_CONFIG = "tibber_hass_config"
 DOMAIN = "tibber"
 MANUFACTURER = "Tibber"
-DATA_API_DEFAULT_SCOPES = [
-    "openid",
-    "profile",
-    "email",
-    "offline_access",
-    "data-api-user-read",
-    "data-api-chargers-read",
-    "data-api-energy-systems-read",
-    "data-api-homes-read",
-    "data-api-thermostats-read",
-    "data-api-vehicles-read",
-    "data-api-inverters-read",
-]

homeassistant/components/tibber/coordinator.py

@@ -4,11 +4,9 @@ from __future__ import annotations
 
 from datetime import timedelta
 import logging
-from typing import TYPE_CHECKING, cast
+from typing import cast
 
-from aiohttp.client_exceptions import ClientError
 import tibber
-from tibber.data_api import TibberDataAPI, TibberDevice
 
 from homeassistant.components.recorder import get_instance
 from homeassistant.components.recorder.models import (
@@ -21,18 +19,15 @@ from homeassistant.components.recorder.statistics import (
     get_last_statistics,
     statistics_during_period,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import UnitOfEnergy
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 from homeassistant.util.unit_conversion import EnergyConverter
 
 from .const import DOMAIN
 
-if TYPE_CHECKING:
-    from .const import TibberConfigEntry
-
 FIVE_YEARS = 5 * 365 * 24
 
 _LOGGER = logging.getLogger(__name__)
@@ -41,12 +36,12 @@ _LOGGER = logging.getLogger(__name__)
 class TibberDataCoordinator(DataUpdateCoordinator[None]):
     """Handle Tibber data and insert statistics."""
 
-    config_entry: TibberConfigEntry
+    config_entry: ConfigEntry
 
     def __init__(
         self,
         hass: HomeAssistant,
-        config_entry: TibberConfigEntry,
+        config_entry: ConfigEntry,
         tibber_connection: tibber.Tibber,
     ) -> None:
         """Initialize the data handler."""
@@ -192,64 +187,3 @@ class TibberDataCoordinator(DataUpdateCoordinator[None]):
                     unit_of_measurement=unit,
                 )
                 async_add_external_statistics(self.hass, metadata, statistics)
-
-
-class TibberDataAPICoordinator(DataUpdateCoordinator[dict[str, TibberDevice]]):
-    """Fetch and cache Tibber Data API device capabilities."""
-
-    config_entry: TibberConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: TibberConfigEntry,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=f"{DOMAIN} Data API",
-            update_interval=timedelta(minutes=1),
-            config_entry=entry,
-        )
-        self._runtime_data = entry.runtime_data
-        self.sensors_by_device: dict[str, dict[str, tibber.data_api.Sensor]] = {}
-
-    def _build_sensor_lookup(self, devices: dict[str, TibberDevice]) -> None:
-        """Build sensor lookup dict for efficient access."""
-        self.sensors_by_device = {
-            device_id: {sensor.id: sensor for sensor in device.sensors}
-            for device_id, device in devices.items()
-        }
-
-    def get_sensor(
-        self, device_id: str, sensor_id: str
-    ) -> tibber.data_api.Sensor | None:
-        """Get a sensor by device and sensor ID."""
-        if device_sensors := self.sensors_by_device.get(device_id):
-            return device_sensors.get(sensor_id)
-        return None
-
-    async def _async_get_client(self) -> TibberDataAPI:
-        """Get the Tibber Data API client with error handling."""
-        try:
-            return await self._runtime_data.async_get_client(self.hass)
-        except ConfigEntryAuthFailed:
-            raise
-        except (ClientError, TimeoutError, tibber.UserAgentMissingError) as err:
-            raise UpdateFailed(
-                f"Unable to create Tibber Data API client: {err}"
-            ) from err
-
-    async def _async_setup(self) -> None:
-        """Initial load of Tibber Data API devices."""
-        client = await self._async_get_client()
-        devices = await client.get_all_devices()
-        self._build_sensor_lookup(devices)
-
-    async def _async_update_data(self) -> dict[str, TibberDevice]:
-        """Fetch the latest device capabilities from the Tibber Data API."""
-        client = await self._async_get_client()
-        devices: dict[str, TibberDevice] = await client.update_devices()
-        self._build_sensor_lookup(devices)
-        return devices

homeassistant/components/tibber/diagnostics.py

@@ -4,18 +4,21 @@ from __future__ import annotations
 
 from typing import Any
 
+import tibber
+
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 
-from .const import TibberConfigEntry
+from .const import DOMAIN
 
 
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: TibberConfigEntry
+    hass: HomeAssistant, config_entry: ConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
+    tibber_connection: tibber.Tibber = hass.data[DOMAIN]
 
-    runtime = config_entry.runtime_data
-    result: dict[str, Any] = {
+    return {
         "homes": [
             {
                 "last_data_timestamp": home.last_data_timestamp,
@@ -24,24 +27,6 @@ async def async_get_config_entry_diagnostics(
                 "last_cons_data_timestamp": home.last_cons_data_timestamp,
                 "country": home.country,
             }
-            for home in runtime.tibber_connection.get_homes(only_active=False)
+            for home in tibber_connection.get_homes(only_active=False)
         ]
     }
-
-    devices = (
-        runtime.data_api_coordinator.data
-        if runtime.data_api_coordinator is not None
-        else {}
-    ) or {}
-
-    result["devices"] = [
-        {
-            "id": device.id,
-            "name": device.name,
-            "brand": device.brand,
-            "model": device.model,
-        }
-        for device in devices.values()
-    ]
-
-    return result

homeassistant/components/tibber/manifest.json

@@ -3,9 +3,9 @@
   "name": "Tibber",
   "codeowners": ["@danielhiversen"],
   "config_flow": true,
-  "dependencies": ["application_credentials", "recorder"],
+  "dependencies": ["recorder"],
   "documentation": "https://www.home-assistant.io/integrations/tibber",
   "iot_class": "cloud_polling",
   "loggers": ["tibber"],
-  "requirements": ["pyTibber==0.34.0"]
+  "requirements": ["pyTibber==0.32.2"]
 }

homeassistant/components/tibber/notify.py

@@ -2,25 +2,28 @@
 
 from __future__ import annotations
 
+from tibber import Tibber
+
 from homeassistant.components.notify import (
     ATTR_TITLE_DEFAULT,
     NotifyEntity,
     NotifyEntityFeature,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN, TibberConfigEntry
+from . import DOMAIN
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: TibberConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Tibber notification entity."""
-    async_add_entities([TibberNotificationEntity(entry)])
+    async_add_entities([TibberNotificationEntity(entry.entry_id)])
 
 
 class TibberNotificationEntity(NotifyEntity):
@@ -30,14 +33,13 @@ class TibberNotificationEntity(NotifyEntity):
     _attr_name = DOMAIN
     _attr_icon = "mdi:message-flash"
 
-    def __init__(self, entry: TibberConfigEntry) -> None:
+    def __init__(self, unique_id: str) -> None:
         """Initialize Tibber notify entity."""
-        self._attr_unique_id = entry.entry_id
-        self._entry = entry
+        self._attr_unique_id = unique_id
 
     async def async_send_message(self, message: str, title: str | None = None) -> None:
         """Send a message to Tibber devices."""
-        tibber_connection = self._entry.runtime_data.tibber_connection
+        tibber_connection: Tibber = self.hass.data[DOMAIN]
         try:
             await tibber_connection.send_notification(
                 title or ATTR_TITLE_DEFAULT, message

homeassistant/components/tibber/sensor.py

@@ -10,8 +10,7 @@ from random import randrange
 from typing import Any
 
 import aiohttp
-from tibber import FatalHttpExceptionError, RetryableHttpExceptionError, TibberHome
-from tibber.data_api import TibberDevice
+import tibber
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -28,9 +27,7 @@ from homeassistant.const import (
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
     UnitOfEnergy,
-    UnitOfLength,
     UnitOfPower,
-    UnitOfTemperature,
 )
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.exceptions import PlatformNotReady
@@ -44,8 +41,8 @@ from homeassistant.helpers.update_coordinator import (
 )
 from homeassistant.util import Throttle, dt as dt_util
 
-from .const import DOMAIN, MANUFACTURER, TibberConfigEntry
-from .coordinator import TibberDataAPICoordinator, TibberDataCoordinator
+from .const import DOMAIN, MANUFACTURER
+from .coordinator import TibberDataCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -263,92 +260,14 @@ SENSORS: tuple[SensorEntityDescription, ...] = (
 )
 
 
-DATA_API_SENSORS: tuple[SensorEntityDescription, ...] = (
-    SensorEntityDescription(
-        key="storage.stateOfCharge",
-        translation_key="storage_state_of_charge",
-        device_class=SensorDeviceClass.BATTERY,
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    SensorEntityDescription(
-        key="storage.targetStateOfCharge",
-        translation_key="storage_target_state_of_charge",
-        device_class=SensorDeviceClass.BATTERY,
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    SensorEntityDescription(
-        key="range.remaining",
-        translation_key="range_remaining",
-        device_class=SensorDeviceClass.DISTANCE,
-        native_unit_of_measurement=UnitOfLength.METERS,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=1,
-    ),
-    SensorEntityDescription(
-        key="charging.current.max",
-        translation_key="charging_current_max",
-        device_class=SensorDeviceClass.CURRENT,
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    SensorEntityDescription(
-        key="charging.current.offlineFallback",
-        translation_key="charging_current_offline_fallback",
-        device_class=SensorDeviceClass.CURRENT,
-        native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    SensorEntityDescription(
-        key="temp.setpoint",
-        translation_key="temp_setpoint",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    SensorEntityDescription(
-        key="temp.current",
-        translation_key="temp_current",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    SensorEntityDescription(
-        key="temp.comfort",
-        translation_key="temp_comfort",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-    ),
-    SensorEntityDescription(
-        key="grid.phaseCount",
-        translation_key="grid_phase_count",
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-)
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: TibberConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Tibber sensor."""
 
-    _setup_data_api_sensors(entry, async_add_entities)
-    await _async_setup_graphql_sensors(hass, entry, async_add_entities)
-
-
-async def _async_setup_graphql_sensors(
-    hass: HomeAssistant,
-    entry: TibberConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the Tibber sensor."""
-
-    tibber_connection = entry.runtime_data.tibber_connection
+    tibber_connection = hass.data[DOMAIN]
 
     entity_registry = er.async_get(hass)
     device_registry = dr.async_get(hass)
@@ -361,11 +280,7 @@ async def _async_setup_graphql_sensors(
         except TimeoutError as err:
             _LOGGER.error("Timeout connecting to Tibber home: %s ", err)
             raise PlatformNotReady from err
-        except (
-            RetryableHttpExceptionError,
-            FatalHttpExceptionError,
-            aiohttp.ClientError,
-        ) as err:
+        except (tibber.RetryableHttpExceptionError, aiohttp.ClientError) as err:
             _LOGGER.error("Error connecting to Tibber home: %s ", err)
             raise PlatformNotReady from err
 
@@ -410,67 +325,7 @@ async def _async_setup_graphql_sensors(
                 device_entry.id, new_identifiers={(DOMAIN, home.home_id)}
             )
 
-    async_add_entities(entities)
-
-
-def _setup_data_api_sensors(
-    entry: TibberConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up sensors backed by the Tibber Data API."""
-
-    coordinator = entry.runtime_data.data_api_coordinator
-    if coordinator is None:
-        return
-
-    entities: list[TibberDataAPISensor] = []
-    api_sensors = {sensor.key: sensor for sensor in DATA_API_SENSORS}
-
-    for device in coordinator.data.values():
-        for sensor in device.sensors:
-            description: SensorEntityDescription | None = api_sensors.get(sensor.id)
-            if description is None:
-                _LOGGER.debug(
-                    "Sensor %s not found in DATA_API_SENSORS, skipping", sensor
-                )
-                continue
-            entities.append(TibberDataAPISensor(coordinator, device, description))
-    async_add_entities(entities)
-
-
-class TibberDataAPISensor(CoordinatorEntity[TibberDataAPICoordinator], SensorEntity):
-    """Representation of a Tibber Data API capability sensor."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: TibberDataAPICoordinator,
-        device: TibberDevice,
-        entity_description: SensorEntityDescription,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-
-        self._device_id: str = device.id
-        self.entity_description = entity_description
-        self._attr_translation_key = entity_description.translation_key
-
-        self._attr_unique_id = f"{device.external_id}_{self.entity_description.key}"
-
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, device.external_id)},
-            name=device.name,
-            manufacturer=device.brand,
-            model=device.model,
-        )
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the value reported by the device."""
-        sensors = self.coordinator.sensors_by_device.get(self._device_id, {})
-        sensor = sensors.get(self.entity_description.key)
-        return sensor.value if sensor else None
+    async_add_entities(entities, True)
 
 
 class TibberSensor(SensorEntity):
@@ -478,7 +333,9 @@ class TibberSensor(SensorEntity):
 
     _attr_has_entity_name = True
 
-    def __init__(self, *args: Any, tibber_home: TibberHome, **kwargs: Any) -> None:
+    def __init__(
+        self, *args: Any, tibber_home: tibber.TibberHome, **kwargs: Any
+    ) -> None:
         """Initialize the sensor."""
         super().__init__(*args, **kwargs)
         self._tibber_home = tibber_home
@@ -509,7 +366,7 @@ class TibberSensorElPrice(TibberSensor):
     _attr_state_class = SensorStateClass.MEASUREMENT
     _attr_translation_key = "electricity_price"
 
-    def __init__(self, tibber_home: TibberHome) -> None:
+    def __init__(self, tibber_home: tibber.TibberHome) -> None:
         """Initialize the sensor."""
         super().__init__(tibber_home=tibber_home)
         self._last_updated: datetime.datetime | None = None
@@ -586,7 +443,7 @@ class TibberDataSensor(TibberSensor, CoordinatorEntity[TibberDataCoordinator]):
 
     def __init__(
         self,
-        tibber_home: TibberHome,
+        tibber_home: tibber.TibberHome,
         coordinator: TibberDataCoordinator,
         entity_description: SensorEntityDescription,
     ) -> None:
@@ -613,7 +470,7 @@ class TibberSensorRT(TibberSensor, CoordinatorEntity["TibberRtDataCoordinator"])
 
     def __init__(
         self,
-        tibber_home: TibberHome,
+        tibber_home: tibber.TibberHome,
         description: SensorEntityDescription,
         initial_state: float,
         coordinator: TibberRtDataCoordinator,
@@ -675,7 +532,7 @@ class TibberRtEntityCreator:
     def __init__(
         self,
         async_add_entities: AddConfigEntryEntitiesCallback,
-        tibber_home: TibberHome,
+        tibber_home: tibber.TibberHome,
         entity_registry: er.EntityRegistry,
     ) -> None:
         """Initialize the data handler."""
@@ -761,7 +618,7 @@ class TibberRtDataCoordinator(DataUpdateCoordinator):  # pylint: disable=hass-en
         hass: HomeAssistant,
         config_entry: ConfigEntry,
         add_sensor_callback: Callable[[TibberRtDataCoordinator, Any], None],
-        tibber_home: TibberHome,
+        tibber_home: tibber.TibberHome,
     ) -> None:
         """Initialize the data handler."""
         self._add_sensor_callback = add_sensor_callback

homeassistant/components/tibber/services.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import datetime as dt
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Final
+from typing import Any, Final
 
 import voluptuous as vol
 
@@ -20,9 +20,6 @@ from homeassistant.util import dt as dt_util
 
 from .const import DOMAIN
 
-if TYPE_CHECKING:
-    from .const import TibberConfigEntry
-
 PRICE_SERVICE_NAME = "get_prices"
 ATTR_START: Final = "start"
 ATTR_END: Final = "end"
@@ -36,13 +33,7 @@ SERVICE_SCHEMA: Final = vol.Schema(
 
 
 async def __get_prices(call: ServiceCall) -> ServiceResponse:
-    entries: list[TibberConfigEntry] = call.hass.config_entries.async_entries(DOMAIN)
-    if not entries:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="no_config_entry",
-        )
-    tibber_connection = entries[0].runtime_data.tibber_connection
+    tibber_connection = call.hass.data[DOMAIN]
 
     start = __get_date(call.data.get(ATTR_START), "start")
     end = __get_date(call.data.get(ATTR_END), "end")
@@ -66,7 +57,7 @@ async def __get_prices(call: ServiceCall) -> ServiceResponse:
         selected_data = [
             price
             for price in price_data
-            if start <= dt.datetime.fromisoformat(str(price["start_time"])) < end
+            if start <= dt.datetime.fromisoformat(price["start_time"]) < end
         ]
         tibber_prices[home_nickname] = selected_data
 

homeassistant/components/tibber/strings.json

@@ -1,11 +1,7 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
-      "missing_credentials": "[%key:common::config_flow::abort::oauth2_missing_credentials%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "wrong_account": "The connected account does not match {title}. Sign in with the same Tibber account and try again."
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -13,10 +9,6 @@
       "timeout": "[%key:common::config_flow::error::timeout_connect%]"
     },
     "step": {
-      "reauth_confirm": {
-        "description": "Reconnect your Tibber account to refresh access.",
-        "title": "[%key:common::config_flow::title::reauth%]"
-      },
       "user": {
         "data": {
           "access_token": "[%key:common::config_flow::data::access_token%]"
@@ -48,12 +40,6 @@
       "average_power": {
         "name": "Average power"
       },
-      "charging_current_max": {
-        "name": "Maximum allowed charge current"
-      },
-      "charging_current_offline_fallback": {
-        "name": "Fallback current if charger goes offline"
-      },
       "current_l1": {
         "name": "Current L1"
       },
@@ -69,9 +55,6 @@
       "estimated_hour_consumption": {
         "name": "Estimated consumption current hour"
       },
-      "grid_phase_count": {
-        "name": "Number of grid phases"
-      },
       "last_meter_consumption": {
         "name": "Last meter consumption"
       },
@@ -105,27 +88,9 @@
       "power_production": {
         "name": "Power production"
       },
-      "range_remaining": {
-        "name": "Estimated remaining driving range"
-      },
       "signal_strength": {
         "name": "Signal strength"
       },
-      "storage_state_of_charge": {
-        "name": "State of charge"
-      },
-      "storage_target_state_of_charge": {
-        "name": "Target state of charge"
-      },
-      "temp_comfort": {
-        "name": "Comfort temperature"
-      },
-      "temp_current": {
-        "name": "Current temperature"
-      },
-      "temp_setpoint": {
-        "name": "Setpoint temperature"
-      },
       "voltage_phase1": {
         "name": "Voltage phase1"
       },
@@ -138,18 +103,9 @@
     }
   },
   "exceptions": {
-    "data_api_reauth_required": {
-      "message": "Reconnect Tibber so Home Assistant can enable the new Tibber Data API features."
-    },
     "invalid_date": {
       "message": "Invalid datetime provided {date}"
     },
-    "no_config_entry": {
-      "message": "No Tibber integration configured"
-    },
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    },
     "send_message_timeout": {
       "message": "Timeout sending message with Tibber"
     }

homeassistant/components/tuya/alarm_control_panel.py

@@ -20,7 +20,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import DeviceWrapper, DPCodeEnumWrapper, DPCodeRawWrapper
+from .models import DPCodeEnumWrapper, DPCodeRawWrapper
 from .type_information import EnumTypeInformation
 
 ALARM: dict[DeviceCategory, tuple[AlarmControlPanelEntityDescription, ...]] = {
@@ -170,9 +170,9 @@ class TuyaAlarmEntity(TuyaEntity, AlarmControlPanelEntity):
         device_manager: Manager,
         description: AlarmControlPanelEntityDescription,
         *,
-        action_wrapper: DeviceWrapper[str],
-        changed_by_wrapper: DeviceWrapper[str] | None,
-        state_wrapper: DeviceWrapper[AlarmControlPanelState],
+        action_wrapper: _AlarmActionWrapper,
+        changed_by_wrapper: _AlarmChangedByWrapper | None,
+        state_wrapper: _AlarmStateWrapper,
     ) -> None:
         """Init Tuya Alarm."""
         super().__init__(device, device_manager)
@@ -183,12 +183,13 @@ class TuyaAlarmEntity(TuyaEntity, AlarmControlPanelEntity):
         self._state_wrapper = state_wrapper
 
         # Determine supported modes
-        if "arm_home" in action_wrapper.options:
-            self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_HOME
-        if "arm_away" in action_wrapper.options:
-            self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_AWAY
-        if "trigger" in action_wrapper.options:
-            self._attr_supported_features |= AlarmControlPanelEntityFeature.TRIGGER
+        if action_wrapper.options:
+            if "arm_home" in action_wrapper.options:
+                self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_HOME
+            if "arm_away" in action_wrapper.options:
+                self._attr_supported_features |= AlarmControlPanelEntityFeature.ARM_AWAY
+            if "trigger" in action_wrapper.options:
+                self._attr_supported_features |= AlarmControlPanelEntityFeature.TRIGGER
 
     @property
     def alarm_state(self) -> AlarmControlPanelState | None:

homeassistant/components/tuya/binary_sensor.py

@@ -19,12 +19,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import (
-    DeviceWrapper,
-    DPCodeBitmapBitWrapper,
-    DPCodeBooleanWrapper,
-    DPCodeWrapper,
-)
+from .models import DPCodeBitmapBitWrapper, DPCodeBooleanWrapper, DPCodeWrapper
 
 
 @dataclass(frozen=True)
@@ -455,7 +450,7 @@ class TuyaBinarySensorEntity(TuyaEntity, BinarySensorEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: TuyaBinarySensorEntityDescription,
-        dpcode_wrapper: DeviceWrapper[bool],
+        dpcode_wrapper: DPCodeWrapper,
     ) -> None:
         """Init Tuya binary sensor."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/button.py

@@ -13,7 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import DeviceWrapper, DPCodeBooleanWrapper
+from .models import DPCodeBooleanWrapper
 
 BUTTONS: dict[DeviceCategory, tuple[ButtonEntityDescription, ...]] = {
     DeviceCategory.HXD: (
@@ -107,7 +107,7 @@ class TuyaButtonEntity(TuyaEntity, ButtonEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: ButtonEntityDescription,
-        dpcode_wrapper: DeviceWrapper[bool],
+        dpcode_wrapper: DPCodeBooleanWrapper,
     ) -> None:
         """Init Tuya button."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/camera.py

@@ -13,7 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import DeviceWrapper, DPCodeBooleanWrapper
+from .models import DPCodeBooleanWrapper
 
 CAMERAS: tuple[DeviceCategory, ...] = (
     DeviceCategory.DGHSXJ,
@@ -70,8 +70,8 @@ class TuyaCameraEntity(TuyaEntity, CameraEntity):
         device: CustomerDevice,
         device_manager: Manager,
         *,
-        motion_detection_switch: DeviceWrapper[bool] | None = None,
-        recording_status: DeviceWrapper[bool] | None = None,
+        motion_detection_switch: DPCodeBooleanWrapper | None = None,
+        recording_status: DPCodeBooleanWrapper | None = None,
     ) -> None:
         """Init Tuya Camera."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/climate.py

@@ -332,14 +332,14 @@ class TuyaClimateEntity(TuyaEntity, ClimateEntity):
         device_manager: Manager,
         description: TuyaClimateEntityDescription,
         *,
-        current_humidity_wrapper: DeviceWrapper[int] | None,
-        current_temperature_wrapper: DeviceWrapper[float] | None,
-        fan_mode_wrapper: DeviceWrapper[str] | None,
-        hvac_mode_wrapper: DeviceWrapper[str] | None,
-        set_temperature_wrapper: DeviceWrapper[float] | None,
-        swing_wrapper: DeviceWrapper[str] | None,
-        switch_wrapper: DeviceWrapper[bool] | None,
-        target_humidity_wrapper: DeviceWrapper[int] | None,
+        current_humidity_wrapper: _RoundedIntegerWrapper | None,
+        current_temperature_wrapper: DPCodeIntegerWrapper | None,
+        fan_mode_wrapper: DPCodeEnumWrapper | None,
+        hvac_mode_wrapper: DPCodeEnumWrapper | None,
+        set_temperature_wrapper: DPCodeIntegerWrapper | None,
+        swing_wrapper: _SwingModeWrapper | None,
+        switch_wrapper: DPCodeBooleanWrapper | None,
+        target_humidity_wrapper: _RoundedIntegerWrapper | None,
         temperature_unit: UnitOfTemperature,
     ) -> None:
         """Determine which values to use."""
@@ -359,11 +359,11 @@ class TuyaClimateEntity(TuyaEntity, ClimateEntity):
 
         # Get integer type data for the dpcode to set temperature, use
         # it to define min, max & step temperatures
-        if set_temperature_wrapper:
+        if self._set_temperature:
             self._attr_supported_features |= ClimateEntityFeature.TARGET_TEMPERATURE
-            self._attr_max_temp = set_temperature_wrapper.max_value
-            self._attr_min_temp = set_temperature_wrapper.min_value
-            self._attr_target_temperature_step = set_temperature_wrapper.value_step
+            self._attr_max_temp = self._set_temperature.max_value
+            self._attr_min_temp = self._set_temperature.min_value
+            self._attr_target_temperature_step = self._set_temperature.value_step
 
         # Determine HVAC modes
         self._attr_hvac_modes: list[HVACMode] = []

homeassistant/components/tuya/cover.py

@@ -111,16 +111,23 @@ class _SpecialInstructionEnumWrapper(_InstructionEnumWrapper):
     _ACTION_MAPPINGS = {"open": "FZ", "close": "ZZ", "stop": "STOP"}
 
 
-class _IsClosedInvertedWrapper(DPCodeBooleanWrapper):
+class _IsClosedWrapper:
+    """Wrapper for checking if cover is closed."""
+
+    def is_closed(self, device: CustomerDevice) -> bool | None:
+        return None
+
+
+class _IsClosedInvertedWrapper(DPCodeBooleanWrapper, _IsClosedWrapper):
     """Boolean wrapper for checking if cover is closed (inverted)."""
 
-    def read_device_status(self, device: CustomerDevice) -> bool | None:
-        if (value := super().read_device_status(device)) is None:
+    def is_closed(self, device: CustomerDevice) -> bool | None:
+        if (value := self.read_device_status(device)) is None:
             return None
         return not value
 
 
-class _IsClosedEnumWrapper(DPCodeEnumWrapper):
+class _IsClosedEnumWrapper(DPCodeEnumWrapper, _IsClosedWrapper):
     """Enum wrapper for checking if state is closed."""
 
     _MAPPINGS = {
@@ -130,15 +137,15 @@ class _IsClosedEnumWrapper(DPCodeEnumWrapper):
         "fully_open": False,
     }
 
-    def read_device_status(self, device: CustomerDevice) -> bool | None:
-        if (value := super().read_device_status(device)) is None:
+    def is_closed(self, device: CustomerDevice) -> bool | None:
+        if (value := self.read_device_status(device)) is None:
             return None
         return self._MAPPINGS.get(value)
 
 
 @dataclass(frozen=True)
 class TuyaCoverEntityDescription(CoverEntityDescription):
-    """Describe a Tuya cover entity."""
+    """Describe an Tuya cover entity."""
 
     current_state: DPCode | tuple[DPCode, ...] | None = None
     current_state_wrapper: type[_IsClosedInvertedWrapper | _IsClosedEnumWrapper] = (
@@ -291,12 +298,12 @@ async def async_setup_entry(
                         current_position=description.position_wrapper.find_dpcode(
                             device, description.current_position
                         ),
-                        current_state_wrapper=description.current_state_wrapper.find_dpcode(
-                            device, description.current_state
-                        ),
                         instruction_wrapper=_get_instruction_wrapper(
                             device, description
                         ),
+                        current_state_wrapper=description.current_state_wrapper.find_dpcode(
+                            device, description.current_state
+                        ),
                         set_position=description.position_wrapper.find_dpcode(
                             device, description.set_position, prefer_function=True
                         ),
@@ -333,11 +340,11 @@ class TuyaCoverEntity(TuyaEntity, CoverEntity):
         device_manager: Manager,
         description: TuyaCoverEntityDescription,
         *,
-        current_position: DeviceWrapper[int] | None,
-        current_state_wrapper: DeviceWrapper[bool] | None,
-        instruction_wrapper: DeviceWrapper[str] | None,
-        set_position: DeviceWrapper[int] | None,
-        tilt_position: DeviceWrapper[int] | None,
+        current_position: _DPCodePercentageMappingWrapper | None,
+        current_state_wrapper: _IsClosedWrapper | None,
+        instruction_wrapper: DeviceWrapper | None,
+        set_position: _DPCodePercentageMappingWrapper | None,
+        tilt_position: _DPCodePercentageMappingWrapper | None,
     ) -> None:
         """Init Tuya Cover."""
         super().__init__(device, device_manager)
@@ -351,7 +358,7 @@ class TuyaCoverEntity(TuyaEntity, CoverEntity):
         self._set_position = set_position
         self._tilt_position = tilt_position
 
-        if instruction_wrapper:
+        if instruction_wrapper and instruction_wrapper.options is not None:
             if "open" in instruction_wrapper.options:
                 self._attr_supported_features |= CoverEntityFeature.OPEN
             if "close" in instruction_wrapper.options:
@@ -384,7 +391,10 @@ class TuyaCoverEntity(TuyaEntity, CoverEntity):
         if (position := self.current_cover_position) is not None:
             return position == 0
 
-        return self._read_wrapper(self._current_state_wrapper)
+        if self._current_state_wrapper:
+            return self._current_state_wrapper.is_closed(self.device)
+
+        return None
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Open the cover."""
@@ -424,7 +434,11 @@ class TuyaCoverEntity(TuyaEntity, CoverEntity):
 
     async def async_stop_cover(self, **kwargs: Any) -> None:
         """Stop the cover."""
-        if self._instruction_wrapper and "stop" in self._instruction_wrapper.options:
+        if (
+            self._instruction_wrapper
+            and (options := self._instruction_wrapper.options)
+            and "stop" in options
+        ):
             await self._async_send_wrapper_updates(self._instruction_wrapper, "stop")
 
     async def async_set_cover_tilt_position(self, **kwargs: Any) -> None:

homeassistant/components/tuya/diagnostics.py

@@ -123,7 +123,6 @@ def _async_device_as_dict(
         data["status_range"][status_range.code] = {
             "type": status_range.type,
             "value": status_range.values,
-            "report_type": status_range.report_type,
         }
 
     # Gather information how this Tuya device is represented in Home Assistant

homeassistant/components/tuya/entity.py

@@ -70,14 +70,14 @@ class TuyaEntity(Entity):
             self.device_manager.send_commands, self.device.id, commands
         )
 
-    def _read_wrapper[T](self, wrapper: DeviceWrapper[T] | None) -> T | None:
+    def _read_wrapper(self, wrapper: DeviceWrapper | None) -> Any | None:
         """Read the wrapper device status."""
         if wrapper is None:
             return None
         return wrapper.read_device_status(self.device)
 
-    async def _async_send_wrapper_updates[T](
-        self, wrapper: DeviceWrapper[T] | None, value: T
+    async def _async_send_wrapper_updates(
+        self, wrapper: DeviceWrapper | None, value: Any
     ) -> None:
         """Send command to the device."""
         if wrapper is None:

homeassistant/components/tuya/event.py

@@ -21,7 +21,6 @@ from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
 from .models import (
-    DeviceWrapper,
     DPCodeEnumWrapper,
     DPCodeRawWrapper,
     DPCodeStringWrapper,
@@ -29,58 +28,75 @@ from .models import (
 )
 
 
-class _EventEnumWrapper(DPCodeEnumWrapper):
-    """Wrapper for event enum DP codes."""
+class _DPCodeEventWrapper(DPCodeTypeInformationWrapper):
+    """Base class for Tuya event wrappers."""
 
-    def read_device_status(self, device: CustomerDevice) -> tuple[str, None] | None:
-        """Return the event details."""
-        if (raw_value := super().read_device_status(device)) is None:
-            return None
-        return (raw_value, None)
-
-
-class _AlarmMessageWrapper(DPCodeStringWrapper):
-    """Wrapper for a STRING message on DPCode.ALARM_MESSAGE."""
+    options: list[str]
 
     def __init__(self, dpcode: str, type_information: Any) -> None:
-        """Init _AlarmMessageWrapper."""
+        """Init _DPCodeEventWrapper."""
         super().__init__(dpcode, type_information)
         self.options = ["triggered"]
 
-    def read_device_status(
-        self, device: CustomerDevice
-    ) -> tuple[str, dict[str, Any]] | None:
-        """Return the event attributes for the alarm message."""
-        if (raw_value := super().read_device_status(device)) is None:
+    def get_event_type(
+        self, device: CustomerDevice, updated_status_properties: list[str] | None
+    ) -> str | None:
+        """Return the event type."""
+        if (
+            updated_status_properties is None
+            or self.dpcode not in updated_status_properties
+        ):
             return None
-        return ("triggered", {"message": b64decode(raw_value).decode("utf-8")})
+        return "triggered"
+
+    def get_event_attributes(self, device: CustomerDevice) -> dict[str, Any] | None:
+        """Return the event attributes."""
+        return None
 
 
-class _DoorbellPicWrapper(DPCodeRawWrapper):
+class _EventEnumWrapper(DPCodeEnumWrapper, _DPCodeEventWrapper):
+    """Wrapper for event enum DP codes."""
+
+    def get_event_type(
+        self, device: CustomerDevice, updated_status_properties: list[str] | None
+    ) -> str | None:
+        """Return the triggered event type."""
+        if (
+            updated_status_properties is None
+            or self.dpcode not in updated_status_properties
+        ):
+            return None
+        return self.read_device_status(device)
+
+
+class _AlarmMessageWrapper(DPCodeStringWrapper, _DPCodeEventWrapper):
+    """Wrapper for a STRING message on DPCode.ALARM_MESSAGE."""
+
+    def get_event_attributes(self, device: CustomerDevice) -> dict[str, Any] | None:
+        """Return the event attributes for the alarm message."""
+        if (raw_value := device.status.get(self.dpcode)) is None:
+            return None
+        return {"message": b64decode(raw_value).decode("utf-8")}
+
+
+class _DoorbellPicWrapper(DPCodeRawWrapper, _DPCodeEventWrapper):
     """Wrapper for a RAW message on DPCode.DOORBELL_PIC.
 
     It is expected that the RAW data is base64/utf8 encoded URL of the picture.
     """
 
-    def __init__(self, dpcode: str, type_information: Any) -> None:
-        """Init _DoorbellPicWrapper."""
-        super().__init__(dpcode, type_information)
-        self.options = ["triggered"]
-
-    def read_device_status(
-        self, device: CustomerDevice
-    ) -> tuple[str, dict[str, Any]] | None:
+    def get_event_attributes(self, device: CustomerDevice) -> dict[str, Any] | None:
         """Return the event attributes for the doorbell picture."""
         if (status := super().read_device_status(device)) is None:
             return None
-        return ("triggered", {"message": status.decode("utf-8")})
+        return {"message": status.decode("utf-8")}
 
 
 @dataclass(frozen=True)
 class TuyaEventEntityDescription(EventEntityDescription):
     """Describe a Tuya Event entity."""
 
-    wrapper_class: type[DPCodeTypeInformationWrapper] = _EventEnumWrapper
+    wrapper_class: type[_DPCodeEventWrapper] = _EventEnumWrapper
 
 
 # All descriptions can be found here. Mostly the Enum data types in the
@@ -206,7 +222,7 @@ class TuyaEventEntity(TuyaEntity, EventEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: EventEntityDescription,
-        dpcode_wrapper: DeviceWrapper[tuple[str, dict[str, Any] | None]],
+        dpcode_wrapper: _DPCodeEventWrapper,
     ) -> None:
         """Init Tuya event entity."""
         super().__init__(device, device_manager)
@@ -220,11 +236,15 @@ class TuyaEventEntity(TuyaEntity, EventEntity):
         updated_status_properties: list[str] | None,
         dp_timestamps: dict | None = None,
     ) -> None:
-        if self._dpcode_wrapper.skip_update(
-            self.device, updated_status_properties
-        ) or not (event_data := self._dpcode_wrapper.read_device_status(self.device)):
+        if (
+            event_type := self._dpcode_wrapper.get_event_type(
+                self.device, updated_status_properties
+            )
+        ) is None:
             return
 
-        event_type, event_attributes = event_data
-        self._trigger_event(event_type, event_attributes)
+        self._trigger_event(
+            event_type,
+            self._dpcode_wrapper.get_event_attributes(self.device),
+        )
         self.async_write_ha_state()

homeassistant/components/tuya/fan.py

@@ -23,12 +23,7 @@ from homeassistant.util.percentage import (
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import (
-    DeviceWrapper,
-    DPCodeBooleanWrapper,
-    DPCodeEnumWrapper,
-    DPCodeIntegerWrapper,
-)
+from .models import DPCodeBooleanWrapper, DPCodeEnumWrapper, DPCodeIntegerWrapper
 from .type_information import IntegerTypeInformation
 from .util import RemapHelper, get_dpcode
 
@@ -178,11 +173,11 @@ class TuyaFanEntity(TuyaEntity, FanEntity):
         device: CustomerDevice,
         device_manager: Manager,
         *,
-        direction_wrapper: DeviceWrapper[str] | None,
-        mode_wrapper: DeviceWrapper[str] | None,
-        oscillate_wrapper: DeviceWrapper[bool] | None,
-        speed_wrapper: DeviceWrapper[int] | None,
-        switch_wrapper: DeviceWrapper[bool] | None,
+        direction_wrapper: _DirectionEnumWrapper | None,
+        mode_wrapper: DPCodeEnumWrapper | None,
+        oscillate_wrapper: DPCodeBooleanWrapper | None,
+        speed_wrapper: _FanSpeedEnumWrapper | _FanSpeedIntegerWrapper | None,
+        switch_wrapper: DPCodeBooleanWrapper | None,
     ) -> None:
         """Init Tuya Fan Device."""
         super().__init__(device, device_manager)
@@ -198,9 +193,7 @@ class TuyaFanEntity(TuyaEntity, FanEntity):
 
         if speed_wrapper:
             self._attr_supported_features |= FanEntityFeature.SET_SPEED
-            # if speed is from an enum, set speed count from options
-            # else keep entity default 100
-            if hasattr(speed_wrapper, "options"):
+            if speed_wrapper.options is not None:
                 self._attr_speed_count = len(speed_wrapper.options)
 
         if oscillate_wrapper:

homeassistant/components/tuya/humidifier.py

@@ -20,12 +20,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import (
-    DeviceWrapper,
-    DPCodeBooleanWrapper,
-    DPCodeEnumWrapper,
-    DPCodeIntegerWrapper,
-)
+from .models import DPCodeBooleanWrapper, DPCodeEnumWrapper, DPCodeIntegerWrapper
 from .util import ActionDPCodeNotFoundError, get_dpcode
 
 
@@ -141,10 +136,10 @@ class TuyaHumidifierEntity(TuyaEntity, HumidifierEntity):
         device_manager: Manager,
         description: TuyaHumidifierEntityDescription,
         *,
-        current_humidity_wrapper: DeviceWrapper[int] | None = None,
-        mode_wrapper: DeviceWrapper[str] | None = None,
-        switch_wrapper: DeviceWrapper[bool] | None = None,
-        target_humidity_wrapper: DeviceWrapper[int] | None = None,
+        current_humidity_wrapper: _RoundedIntegerWrapper | None = None,
+        mode_wrapper: DPCodeEnumWrapper | None = None,
+        switch_wrapper: DPCodeBooleanWrapper | None = None,
+        target_humidity_wrapper: _RoundedIntegerWrapper | None = None,
     ) -> None:
         """Init Tuya (de)humidifier."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/light.py

@@ -31,7 +31,6 @@ from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode, WorkMode
 from .entity import TuyaEntity
 from .models import (
-    DeviceWrapper,
     DPCodeBooleanWrapper,
     DPCodeEnumWrapper,
     DPCodeIntegerWrapper,
@@ -187,14 +186,14 @@ class _ColorDataWrapper(DPCodeJsonWrapper):
         )
 
     def _convert_value_to_raw_value(
-        self, device: CustomerDevice, value: tuple[float, float, float]
+        self, device: CustomerDevice, value: tuple[tuple[float, float], float]
     ) -> Any:
-        """Convert a Home Assistant tuple (H, S, V) back to a raw device value."""
-        hue, saturation, brightness = value
+        """Convert a Home Assistant color/brightness pair back to a raw device value."""
+        color, brightness = value
         return json.dumps(
             {
-                "h": round(self.h_type.remap_value_from(hue)),
-                "s": round(self.s_type.remap_value_from(saturation)),
+                "h": round(self.h_type.remap_value_from(color[0])),
+                "s": round(self.s_type.remap_value_from(color[1])),
                 "v": round(self.v_type.remap_value_from(brightness)),
             }
         )
@@ -674,11 +673,11 @@ class TuyaLightEntity(TuyaEntity, LightEntity):
         device_manager: Manager,
         description: TuyaLightEntityDescription,
         *,
-        brightness_wrapper: DeviceWrapper[int] | None,
-        color_data_wrapper: DeviceWrapper[tuple[float, float, float]] | None,
-        color_mode_wrapper: DeviceWrapper[str] | None,
-        color_temp_wrapper: DeviceWrapper[int] | None,
-        switch_wrapper: DeviceWrapper[bool],
+        brightness_wrapper: _BrightnessWrapper | None,
+        color_data_wrapper: _ColorDataWrapper | None,
+        color_mode_wrapper: DPCodeEnumWrapper | None,
+        color_temp_wrapper: _ColorTempWrapper | None,
+        switch_wrapper: DPCodeBooleanWrapper,
     ) -> None:
         """Init TuyaHaLight."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/manifest.json

@@ -43,5 +43,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["tuya_sharing"],
-  "requirements": ["tuya-device-sharing-sdk==0.2.8"]
+  "requirements": ["tuya-device-sharing-sdk==0.2.7"]
 }

homeassistant/components/tuya/models.py

@@ -18,33 +18,17 @@ from .type_information import (
 )
 
 
-class DeviceWrapper[T]:
+class DeviceWrapper:
     """Base device wrapper."""
 
-    native_unit: str | None = None
-    suggested_unit: str | None = None
+    options: list[str] | None = None
 
-    max_value: float
-    min_value: float
-    value_step: float
-
-    options: list[str]
-
-    def skip_update(
-        self, device: CustomerDevice, updated_status_properties: list[str] | None
-    ) -> bool:
-        """Determine if the wrapper should skip an update.
-
-        The default is to always skip, unless overridden in subclasses.
-        """
-        return True
-
-    def read_device_status(self, device: CustomerDevice) -> T | None:
+    def read_device_status(self, device: CustomerDevice) -> Any | None:
         """Read device status and convert to a Home Assistant value."""
         raise NotImplementedError
 
     def get_update_commands(
-        self, device: CustomerDevice, value: T
+        self, device: CustomerDevice, value: Any
     ) -> list[dict[str, Any]]:
         """Generate update commands for a Home Assistant action."""
         raise NotImplementedError
@@ -57,23 +41,13 @@ class DPCodeWrapper(DeviceWrapper):
     access read conversion routines.
     """
 
+    native_unit: str | None = None
+    suggested_unit: str | None = None
+
     def __init__(self, dpcode: str) -> None:
         """Init DPCodeWrapper."""
         self.dpcode = dpcode
 
-    def skip_update(
-        self, device: CustomerDevice, updated_status_properties: list[str] | None
-    ) -> bool:
-        """Determine if the wrapper should skip an update.
-
-        By default, skip if updated_status_properties is given and
-        does not include this dpcode.
-        """
-        return (
-            updated_status_properties is None
-            or self.dpcode not in updated_status_properties
-        )
-
     def _convert_value_to_raw_value(self, device: CustomerDevice, value: Any) -> Any:
         """Convert a Home Assistant value back to a raw device value.
 
@@ -161,6 +135,7 @@ class DPCodeEnumWrapper(DPCodeTypeInformationWrapper[EnumTypeInformation]):
     """Simple wrapper for EnumTypeInformation values."""
 
     _DPTYPE = EnumTypeInformation
+    options: list[str]
 
     def __init__(self, dpcode: str, type_information: EnumTypeInformation) -> None:
         """Init DPCodeEnumWrapper."""

homeassistant/components/tuya/number.py

@@ -25,7 +25,7 @@ from .const import (
     DPCode,
 )
 from .entity import TuyaEntity
-from .models import DeviceWrapper, DPCodeIntegerWrapper
+from .models import DPCodeIntegerWrapper
 
 NUMBERS: dict[DeviceCategory, tuple[NumberEntityDescription, ...]] = {
     DeviceCategory.BH: (
@@ -488,7 +488,7 @@ class TuyaNumberEntity(TuyaEntity, NumberEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: NumberEntityDescription,
-        dpcode_wrapper: DeviceWrapper[float],
+        dpcode_wrapper: DPCodeIntegerWrapper,
     ) -> None:
         """Init Tuya sensor."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/select.py

@@ -13,7 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import DeviceWrapper, DPCodeEnumWrapper
+from .models import DPCodeEnumWrapper
 
 # All descriptions can be found here. Mostly the Enum data types in the
 # default instructions set of each category end up being a select.
@@ -393,7 +393,7 @@ class TuyaSelectEntity(TuyaEntity, SelectEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: SelectEntityDescription,
-        dpcode_wrapper: DeviceWrapper[str],
+        dpcode_wrapper: DPCodeEnumWrapper,
     ) -> None:
         """Init Tuya sensor."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/sensor.py

@@ -39,7 +39,6 @@ from .const import (
 )
 from .entity import TuyaEntity
 from .models import (
-    DeviceWrapper,
     DPCodeEnumWrapper,
     DPCodeIntegerWrapper,
     DPCodeJsonWrapper,
@@ -1780,13 +1779,14 @@ class TuyaSensorEntity(TuyaEntity, SensorEntity):
     """Tuya Sensor Entity."""
 
     entity_description: TuyaSensorEntityDescription
+    _dpcode_wrapper: DPCodeWrapper
 
     def __init__(
         self,
         device: CustomerDevice,
         device_manager: Manager,
         description: TuyaSensorEntityDescription,
-        dpcode_wrapper: DeviceWrapper[StateType],
+        dpcode_wrapper: DPCodeWrapper,
     ) -> None:
         """Init Tuya sensor."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/siren.py

@@ -19,7 +19,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import TuyaConfigEntry
 from .const import TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import DeviceWrapper, DPCodeBooleanWrapper
+from .models import DPCodeBooleanWrapper
 
 SIRENS: dict[DeviceCategory, tuple[SirenEntityDescription, ...]] = {
     DeviceCategory.CO2BJ: (
@@ -94,7 +94,7 @@ class TuyaSirenEntity(TuyaEntity, SirenEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: SirenEntityDescription,
-        dpcode_wrapper: DeviceWrapper[bool],
+        dpcode_wrapper: DPCodeBooleanWrapper,
     ) -> None:
         """Init Tuya Siren."""
         super().__init__(device, device_manager)

homeassistant/components/tuya/switch.py

@@ -27,7 +27,7 @@ from homeassistant.helpers.issue_registry import (
 from . import TuyaConfigEntry
 from .const import DOMAIN, TUYA_DISCOVERY_NEW, DeviceCategory, DPCode
 from .entity import TuyaEntity
-from .models import DeviceWrapper, DPCodeBooleanWrapper
+from .models import DPCodeBooleanWrapper
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -1027,7 +1027,7 @@ class TuyaSwitchEntity(TuyaEntity, SwitchEntity):
         device: CustomerDevice,
         device_manager: Manager,
         description: SwitchEntityDescription,
-        dpcode_wrapper: DeviceWrapper[bool],
+        dpcode_wrapper: DPCodeBooleanWrapper,
     ) -> None:
         """Init TuyaHaSwitch."""
         super().__init__(device, device_manager)