Add decorator to define Python tools from Python functions

.claude/agents/quality-scale-rule-verifier.md

@@ -1,77 +0,0 @@
----
-name: quality-scale-rule-verifier
-description: |
-  Use this agent when you need to verify that a Home Assistant integration follows a specific quality scale rule. This includes checking if the integration implements required patterns, configurations, or code structures defined by the quality scale system.
-
-  <example>
-  Context: The user wants to verify if an integration follows a specific quality scale rule.
-  user: "Check if the peblar integration follows the config-flow rule"
-  assistant: "I'll use the quality scale rule verifier to check if the peblar integration properly implements the config-flow rule."
-  <commentary>
-  Since the user is asking to verify a quality scale rule implementation, use the quality-scale-rule-verifier agent.
-  </commentary>
-  </example>
-
-  <example>
-  Context: The user is reviewing if an integration reaches a specific quality scale level.
-  user: "Verify that this integration reaches the bronze quality scale"
-  assistant: "Let me use the quality scale rule verifier to check the bronze quality scale implementation."
-  <commentary>
-  The user wants to verify the integration has reached a certain quality level, so use multiple quality-scale-rule-verifier agents to verify each bronze rule.
-  </commentary>
-  </example>
-model: inherit
-color: yellow
-tools: Read, Bash, Grep, Glob, WebFetch
----
-
-You are an expert Home Assistant integration quality scale auditor specializing in verifying compliance with specific quality scale rules. You have deep knowledge of Home Assistant's architecture, best practices, and the quality scale system that ensures integration consistency and reliability.
-
-You will verify if an integration follows a specific quality scale rule by:
-
-1. **Fetching Rule Documentation**: Retrieve the official rule documentation from:
-   `https://raw.githubusercontent.com/home-assistant/developers.home-assistant/refs/heads/master/docs/core/integration-quality-scale/rules/{rule_name}.md`
-   where `{rule_name}` is the rule identifier (e.g., 'config-flow', 'entity-unique-id', 'parallel-updates')
-
-2. **Understanding Rule Requirements**: Parse the rule documentation to identify:
-   - Core requirements and mandatory implementations
-   - Specific code patterns or configurations required
-   - Common violations and anti-patterns
-   - Exemption criteria (when a rule might not apply)
-   - The quality tier this rule belongs to (Bronze, Silver, Gold, Platinum)
-
-3. **Analyzing Integration Code**: Examine the integration's codebase at `homeassistant/components/<integration domain>` focusing on:
-   - `manifest.json` for quality scale declaration and configuration
-   - `quality_scale.yaml` for rule status (done, todo, exempt)
-   - Relevant Python modules based on the rule requirements
-   - Configuration files and service definitions as needed
-
-4. **Verification Process**:
-   - Check if the rule is marked as 'done', 'todo', or 'exempt' in quality_scale.yaml
-   - If marked 'exempt', verify the exemption reason is valid
-   - If marked 'done', verify the actual implementation matches requirements
-   - Identify specific files and code sections that demonstrate compliance or violations
-   - Consider the integration's declared quality tier when applying rules
-   - To fetch the integration docs, use WebFetch to fetch from `https://raw.githubusercontent.com/home-assistant/home-assistant.io/refs/heads/current/source/_integrations/<integration domain>.markdown`
-   - To fetch information about a PyPI package, use the URL `https://pypi.org/pypi/<package>/json`
-
-5. **Reporting Findings**: Provide a comprehensive verification report that includes:
-   - **Rule Summary**: Brief description of what the rule requires
-   - **Compliance Status**: Clear pass/fail/exempt determination
-   - **Evidence**: Specific code examples showing compliance or violations
-   - **Issues Found**: Detailed list of any non-compliance issues with file locations
-   - **Recommendations**: Actionable steps to achieve compliance if needed
-   - **Exemption Analysis**: If applicable, whether the exemption is justified
-
-When examining code, you will:
-- Look for exact implementation patterns specified in the rule
-- Verify all required components are present and properly configured
-- Check for common mistakes and anti-patterns
-- Consider edge cases and error handling requirements
-- Validate that implementations follow Home Assistant conventions
-
-You will be thorough but focused, examining only the aspects relevant to the specific rule being verified. You will provide clear, actionable feedback that helps developers understand both what needs to be fixed and why it matters for integration quality.
-
-If you cannot access the rule documentation or find the integration code, clearly state what information is missing and what you would need to complete the verification.
-
-Remember that quality scale rules are cumulative - Bronze rules apply to all integrations with a quality scale, Silver rules apply to Silver+ integrations, and so on. Always consider the integration's target quality level when determining which rules should be enforced.

.claude/skills/ha-integration/BINARY-SENSOR.MD

@@ -1,238 +0,0 @@
-# Binary Sensor Platform Reference
-
-Binary sensors represent on/off states.
-
-## Basic Binary Sensor
-
-```python
-"""Binary sensor platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntity,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up binary sensors from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        DoorSensor(coordinator),
-        MotionSensor(coordinator),
-    ])
-
-
-class DoorSensor(MyEntity, BinarySensorEntity):
-    """Door open/close sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.DOOR
-    _attr_translation_key = "door"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_door"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if door is open."""
-        return self.coordinator.data.door_open
-```
-
-## Device Classes
-
-Common binary sensor device classes:
-
-| Device Class | On Means | Off Means |
-|--------------|----------|-----------|
-| `BATTERY` | Low | Normal |
-| `BATTERY_CHARGING` | Charging | Not charging |
-| `CONNECTIVITY` | Connected | Disconnected |
-| `DOOR` | Open | Closed |
-| `GARAGE_DOOR` | Open | Closed |
-| `LOCK` | Unlocked | Locked |
-| `MOISTURE` | Wet | Dry |
-| `MOTION` | Motion detected | Clear |
-| `OCCUPANCY` | Occupied | Clear |
-| `OPENING` | Open | Closed |
-| `PLUG` | Plugged in | Unplugged |
-| `POWER` | Power detected | No power |
-| `PRESENCE` | Present | Away |
-| `PROBLEM` | Problem | OK |
-| `RUNNING` | Running | Not running |
-| `SAFETY` | Unsafe | Safe |
-| `SMOKE` | Smoke detected | Clear |
-| `SOUND` | Sound detected | Clear |
-| `TAMPER` | Tampering | Clear |
-| `UPDATE` | Update available | Up-to-date |
-| `VIBRATION` | Vibration | Clear |
-| `WINDOW` | Open | Closed |
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntityDescription,
-)
-
-
-@dataclass(frozen=True, kw_only=True)
-class MyBinarySensorEntityDescription(BinarySensorEntityDescription):
-    """Describe My binary sensor entity."""
-
-    is_on_fn: Callable[[MyData], bool | None]
-
-
-BINARY_SENSORS: tuple[MyBinarySensorEntityDescription, ...] = (
-    MyBinarySensorEntityDescription(
-        key="door",
-        translation_key="door",
-        device_class=BinarySensorDeviceClass.DOOR,
-        is_on_fn=lambda data: data.door_open,
-    ),
-    MyBinarySensorEntityDescription(
-        key="motion",
-        translation_key="motion",
-        device_class=BinarySensorDeviceClass.MOTION,
-        is_on_fn=lambda data: data.motion_detected,
-    ),
-    MyBinarySensorEntityDescription(
-        key="low_battery",
-        translation_key="low_battery",
-        device_class=BinarySensorDeviceClass.BATTERY,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        is_on_fn=lambda data: data.battery_level < 20 if data.battery_level else None,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up binary sensors from config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        MyBinarySensor(coordinator, description)
-        for description in BINARY_SENSORS
-    )
-
-
-class MyBinarySensor(MyEntity, BinarySensorEntity):
-    """Binary sensor using entity description."""
-
-    entity_description: MyBinarySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MyBinarySensorEntityDescription,
-    ) -> None:
-        """Initialize the binary sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if the binary sensor is on."""
-        return self.entity_description.is_on_fn(self.coordinator.data)
-```
-
-## Connectivity Sensor
-
-```python
-class ConnectivitySensor(MyEntity, BinarySensorEntity):
-    """Device connectivity sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.CONNECTIVITY
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "connectivity"
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if device is connected."""
-        return self.coordinator.data.is_connected
-```
-
-## Problem Sensor
-
-```python
-class ProblemSensor(MyEntity, BinarySensorEntity):
-    """Problem indicator sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.PROBLEM
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "problem"
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if there's a problem."""
-        return self.coordinator.data.has_error
-
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return extra state attributes."""
-        return {
-            "error_code": self.coordinator.data.error_code,
-            "error_message": self.coordinator.data.error_message,
-        }
-```
-
-## Update Available Sensor
-
-```python
-class UpdateAvailableSensor(MyEntity, BinarySensorEntity):
-    """Firmware update available sensor."""
-
-    _attr_device_class = BinarySensorDeviceClass.UPDATE
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "update_available"
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if an update is available."""
-        return self.coordinator.data.update_available
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "binary_sensor": {
-      "door": {
-        "name": "Door"
-      },
-      "motion": {
-        "name": "Motion"
-      },
-      "low_battery": {
-        "name": "Low battery"
-      },
-      "connectivity": {
-        "name": "Connectivity"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/BUTTON.MD

@@ -1,201 +0,0 @@
-# Button Platform Reference
-
-Button entities trigger actions when pressed.
-
-## Basic Button
-
-```python
-"""Button platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.button import ButtonDeviceClass, ButtonEntity
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up buttons from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        RestartButton(coordinator),
-        IdentifyButton(coordinator),
-    ])
-
-
-class RestartButton(MyEntity, ButtonEntity):
-    """Restart button."""
-
-    _attr_device_class = ButtonDeviceClass.RESTART
-    _attr_translation_key = "restart"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the button."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_restart"
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        await self.coordinator.client.restart()
-```
-
-## Device Classes
-
-| Device Class | Icon | Use Case |
-|--------------|------|----------|
-| `IDENTIFY` | mdi:crosshairs-question | Flash light/beep to locate device |
-| `RESTART` | mdi:restart | Restart the device |
-| `UPDATE` | mdi:package-up | Trigger firmware update |
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.button import ButtonDeviceClass, ButtonEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MyButtonEntityDescription(ButtonEntityDescription):
-    """Describe My button entity."""
-
-    press_fn: Callable[[MyClient], Coroutine[Any, Any, None]]
-
-
-BUTTONS: tuple[MyButtonEntityDescription, ...] = (
-    MyButtonEntityDescription(
-        key="restart",
-        translation_key="restart",
-        device_class=ButtonDeviceClass.RESTART,
-        entity_category=EntityCategory.CONFIG,
-        press_fn=lambda client: client.restart(),
-    ),
-    MyButtonEntityDescription(
-        key="identify",
-        translation_key="identify",
-        device_class=ButtonDeviceClass.IDENTIFY,
-        entity_category=EntityCategory.CONFIG,
-        press_fn=lambda client: client.identify(),
-    ),
-    MyButtonEntityDescription(
-        key="factory_reset",
-        translation_key="factory_reset",
-        entity_category=EntityCategory.CONFIG,
-        press_fn=lambda client: client.factory_reset(),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up buttons from config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        MyButton(coordinator, description)
-        for description in BUTTONS
-    )
-
-
-class MyButton(MyEntity, ButtonEntity):
-    """Button using entity description."""
-
-    entity_description: MyButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MyButtonEntityDescription,
-    ) -> None:
-        """Initialize the button."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    async def async_press(self) -> None:
-        """Handle the button press."""
-        await self.entity_description.press_fn(self.coordinator.client)
-```
-
-## Identify Button
-
-```python
-class IdentifyButton(MyEntity, ButtonEntity):
-    """Identify button to locate the device."""
-
-    _attr_device_class = ButtonDeviceClass.IDENTIFY
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_translation_key = "identify"
-
-    async def async_press(self) -> None:
-        """Flash the device LED to identify it."""
-        await self.coordinator.client.identify()
-```
-
-## Error Handling
-
-```python
-from homeassistant.exceptions import HomeAssistantError
-
-
-class SafeButton(MyEntity, ButtonEntity):
-    """Button with error handling."""
-
-    async def async_press(self) -> None:
-        """Handle the button press with error handling."""
-        try:
-            await self.coordinator.client.perform_action()
-        except MyDeviceError as err:
-            raise HomeAssistantError(f"Failed to perform action: {err}") from err
-```
-
-## Confirmation Buttons
-
-For dangerous operations, consider using a diagnostic category and clear naming:
-
-```python
-class FactoryResetButton(MyEntity, ButtonEntity):
-    """Factory reset button."""
-
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_translation_key = "factory_reset"
-    _attr_entity_registry_enabled_default = False  # Disabled by default
-
-    async def async_press(self) -> None:
-        """Perform factory reset."""
-        await self.coordinator.client.factory_reset()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "button": {
-      "restart": {
-        "name": "Restart"
-      },
-      "identify": {
-        "name": "Identify"
-      },
-      "factory_reset": {
-        "name": "Factory reset"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/CONFIG-FLOW.MD

@@ -1,254 +0,0 @@
-# Config Flow Reference
-
-Configuration flows allow users to set up integrations via the UI.
-
-## Basic Config Flow
-
-```python
-"""Config flow for My Integration."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_API_KEY
-from homeassistant.helpers.selector import TextSelector
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_HOST): TextSelector(),
-        vol.Required(CONF_API_KEY): TextSelector(),
-    }
-)
-
-
-class MyIntegrationConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for My Integration."""
-
-    VERSION = 1
-    MINOR_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:
-            try:
-                # Test connection
-                client = MyClient(user_input[CONF_HOST], user_input[CONF_API_KEY])
-                info = await client.get_device_info()
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except InvalidAuth:
-                errors["base"] = "invalid_auth"
-            except Exception:
-                _LOGGER.exception("Unexpected exception")
-                errors["base"] = "unknown"
-            else:
-                # Set unique ID and abort if already configured
-                await self.async_set_unique_id(info.serial_number)
-                self._abort_if_unique_id_configured()
-
-                return self.async_create_entry(
-                    title=info.name,
-                    data=user_input,
-                )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=STEP_USER_DATA_SCHEMA,
-            errors=errors,
-        )
-```
-
-## Version Control
-
-Always set version numbers:
-
-```python
-VERSION = 1        # Bump for breaking changes requiring migration
-MINOR_VERSION = 1  # Bump for backward-compatible changes
-```
-
-## Unique ID Management
-
-```python
-# Set unique ID and abort if exists
-await self.async_set_unique_id(device_serial)
-self._abort_if_unique_id_configured()
-
-# Or abort if data matches (when no unique ID available)
-self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
-```
-
-## Reauthentication Flow
-
-```python
-async def async_step_reauth(
-    self, entry_data: Mapping[str, Any]
-) -> ConfigFlowResult:
-    """Handle reauthentication."""
-    return await self.async_step_reauth_confirm()
-
-async def async_step_reauth_confirm(
-    self, user_input: dict[str, Any] | None = None
-) -> ConfigFlowResult:
-    """Handle reauthentication confirmation."""
-    errors: dict[str, str] = {}
-
-    if user_input is not None:
-        try:
-            client = MyClient(
-                self._get_reauth_entry().data[CONF_HOST],
-                user_input[CONF_API_KEY]
-            )
-            info = await client.get_device_info()
-        except InvalidAuth:
-            errors["base"] = "invalid_auth"
-        except Exception:
-            errors["base"] = "unknown"
-        else:
-            await self.async_set_unique_id(info.serial_number)
-            self._abort_if_unique_id_mismatch(reason="wrong_account")
-            return self.async_update_reload_and_abort(
-                self._get_reauth_entry(),
-                data_updates={CONF_API_KEY: user_input[CONF_API_KEY]},
-            )
-
-    return self.async_show_form(
-        step_id="reauth_confirm",
-        data_schema=vol.Schema({vol.Required(CONF_API_KEY): str}),
-        errors=errors,
-    )
-```
-
-## Reconfiguration Flow
-
-```python
-async def async_step_reconfigure(
-    self, user_input: dict[str, Any] | None = None
-) -> ConfigFlowResult:
-    """Handle reconfiguration."""
-    errors: dict[str, str] = {}
-    reconfigure_entry = self._get_reconfigure_entry()
-
-    if user_input is not None:
-        try:
-            client = MyClient(user_input[CONF_HOST], reconfigure_entry.data[CONF_API_KEY])
-            info = await client.get_device_info()
-        except CannotConnect:
-            errors["base"] = "cannot_connect"
-        else:
-            await self.async_set_unique_id(info.serial_number)
-            self._abort_if_unique_id_mismatch(reason="wrong_device")
-            return self.async_update_reload_and_abort(
-                reconfigure_entry,
-                data_updates={CONF_HOST: user_input[CONF_HOST]},
-            )
-
-    return self.async_show_form(
-        step_id="reconfigure",
-        data_schema=vol.Schema({
-            vol.Required(CONF_HOST, default=reconfigure_entry.data[CONF_HOST]): str
-        }),
-        errors=errors,
-    )
-```
-
-## Discovery Flows
-
-### Zeroconf Discovery
-
-```python
-async def async_step_zeroconf(
-    self, discovery_info: ZeroconfServiceInfo
-) -> ConfigFlowResult:
-    """Handle zeroconf discovery."""
-    serial = discovery_info.properties.get("serialno")
-    if not serial:
-        return self.async_abort(reason="no_serial")
-
-    await self.async_set_unique_id(serial)
-    self._abort_if_unique_id_configured(
-        updates={CONF_HOST: str(discovery_info.host)}
-    )
-
-    self._discovered_host = str(discovery_info.host)
-    self._discovered_name = discovery_info.name.removesuffix("._mydevice._tcp.local.")
-
-    return await self.async_step_discovery_confirm()
-
-async def async_step_discovery_confirm(
-    self, user_input: dict[str, Any] | None = None
-) -> ConfigFlowResult:
-    """Confirm discovery."""
-    if user_input is not None:
-        return self.async_create_entry(
-            title=self._discovered_name,
-            data={CONF_HOST: self._discovered_host},
-        )
-
-    self._set_confirm_only()
-    return self.async_show_form(
-        step_id="discovery_confirm",
-        description_placeholders={"name": self._discovered_name},
-    )
-```
-
-## strings.json for Config Flow
-
-```json
-{
-  "config": {
-    "step": {
-      "user": {
-        "title": "Connect to device",
-        "description": "Enter your device credentials.",
-        "data": {
-          "host": "Host",
-          "api_key": "API key"
-        }
-      },
-      "reauth_confirm": {
-        "title": "Reauthenticate",
-        "description": "Please enter a new API key for {name}.",
-        "data": {
-          "api_key": "API key"
-        }
-      },
-      "discovery_confirm": {
-        "title": "Discovered device",
-        "description": "Do you want to set up {name}?"
-      }
-    },
-    "error": {
-      "cannot_connect": "Failed to connect",
-      "invalid_auth": "Invalid authentication",
-      "unknown": "Unexpected error"
-    },
-    "abort": {
-      "already_configured": "Device is already configured",
-      "wrong_account": "Wrong account",
-      "wrong_device": "Wrong device"
-    }
-  }
-}
-```
-
-## Key Rules
-
-1. **Never allow user-configurable entry names** (except helper integrations)
-2. **Always test connection** before creating entry
-3. **Always set unique ID** when possible
-4. **Handle all exceptions** - bare `except Exception:` is allowed in config flows
-5. **100% test coverage required** for all flow paths

.claude/skills/ha-integration/COORDINATOR.MD

@@ -1,239 +0,0 @@
-# Data Update Coordinator Reference
-
-The coordinator pattern centralizes data fetching and provides efficient polling.
-
-## Basic Coordinator
-
-```python
-"""DataUpdateCoordinator for My Integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import logging
-from typing import TYPE_CHECKING
-
-from my_library import MyClient, MyData, MyError, AuthError
-
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN
-
-if TYPE_CHECKING:
-    from . import MyIntegrationConfigEntry
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    """My integration data update coordinator."""
-
-    config_entry: MyIntegrationConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: MyIntegrationConfigEntry,
-        client: MyClient,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=timedelta(minutes=1),
-            config_entry=entry,
-        )
-        self.client = client
-
-    async def _async_update_data(self) -> MyData:
-        """Fetch data from API."""
-        try:
-            return await self.client.get_data()
-        except AuthError as err:
-            raise ConfigEntryAuthFailed("Invalid credentials") from err
-        except MyError as err:
-            raise UpdateFailed(f"Error communicating with API: {err}") from err
-```
-
-## Key Points
-
-### Always Pass config_entry
-
-```python
-super().__init__(
-    hass,
-    logger=_LOGGER,
-    name=DOMAIN,
-    update_interval=timedelta(minutes=1),
-    config_entry=entry,  # Always include this
-)
-```
-
-### Generic Type Parameter
-
-Specify the data type returned by `_async_update_data`:
-
-```python
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    ...
-```
-
-### Error Types
-
-- **`UpdateFailed`**: API communication errors (will retry)
-- **`ConfigEntryAuthFailed`**: Authentication issues (triggers reauth flow)
-
-## Polling Intervals
-
-**Integration determines intervals** - never make them user-configurable.
-
-```python
-# Constants (in const.py)
-SCAN_INTERVAL_LOCAL = timedelta(seconds=30)
-SCAN_INTERVAL_CLOUD = timedelta(minutes=5)
-
-# In coordinator
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    def __init__(self, hass: HomeAssistant, entry: MyIntegrationConfigEntry, client: MyClient) -> None:
-        # Determine interval based on connection type
-        interval = SCAN_INTERVAL_LOCAL if client.is_local else SCAN_INTERVAL_CLOUD
-
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=interval,
-            config_entry=entry,
-        )
-```
-
-**Minimum intervals:**
-- Local network: 5 seconds
-- Cloud services: 60 seconds
-
-## Coordinator with Device Info
-
-```python
-from homeassistant.helpers.device_registry import DeviceInfo
-
-from .const import DOMAIN
-
-
-class MyCoordinator(DataUpdateCoordinator[MyData]):
-    """Coordinator with device information."""
-
-    config_entry: MyIntegrationConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: MyIntegrationConfigEntry,
-        client: MyClient,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            logger=_LOGGER,
-            name=DOMAIN,
-            update_interval=timedelta(minutes=1),
-            config_entry=entry,
-        )
-        self.client = client
-        self.device_info = DeviceInfo(
-            identifiers={(DOMAIN, client.serial_number)},
-            name=client.name,
-            manufacturer="My Company",
-            model=client.model,
-            sw_version=client.firmware_version,
-        )
-
-    async def _async_update_data(self) -> MyData:
-        """Fetch data from API."""
-        try:
-            return await self.client.get_data()
-        except MyError as err:
-            raise UpdateFailed(f"Error communicating with API: {err}") from err
-```
-
-## Multiple Data Sources
-
-```python
-from dataclasses import dataclass
-
-
-@dataclass
-class MyCoordinatorData:
-    """Data class for coordinator."""
-
-    sensors: dict[str, SensorData]
-    status: DeviceStatus
-    settings: DeviceSettings
-
-
-class MyCoordinator(DataUpdateCoordinator[MyCoordinatorData]):
-    """Coordinator for multiple data sources."""
-
-    async def _async_update_data(self) -> MyCoordinatorData:
-        """Fetch all data sources."""
-        try:
-            # Fetch all data concurrently
-            sensors, status, settings = await asyncio.gather(
-                self.client.get_sensors(),
-                self.client.get_status(),
-                self.client.get_settings(),
-            )
-        except MyError as err:
-            raise UpdateFailed(f"Error fetching data: {err}") from err
-
-        return MyCoordinatorData(
-            sensors=sensors,
-            status=status,
-            settings=settings,
-        )
-```
-
-## Setup in __init__.py
-
-```python
-async def async_setup_entry(hass: HomeAssistant, entry: MyIntegrationConfigEntry) -> bool:
-    """Set up My Integration from a config entry."""
-    client = MyClient(entry.data[CONF_HOST], entry.data[CONF_API_KEY])
-
-    coordinator = MyCoordinator(hass, entry, client)
-
-    # Perform first refresh - raises ConfigEntryNotReady on failure
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-```
-
-## Testing Coordinators
-
-```python
-@pytest.fixture
-def mock_coordinator(hass: HomeAssistant, mock_config_entry: MockConfigEntry) -> MyCoordinator:
-    """Return a mocked coordinator."""
-    coordinator = MyCoordinator(hass, mock_config_entry, MagicMock())
-    coordinator.data = MyData(temperature=21.5, humidity=45)
-    return coordinator
-
-
-async def test_coordinator_update_failed(
-    hass: HomeAssistant,
-    mock_client: MagicMock,
-) -> None:
-    """Test coordinator handles update failure."""
-    mock_client.get_data.side_effect = MyError("Connection failed")
-
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-
-    with pytest.raises(UpdateFailed):
-        await coordinator._async_update_data()
-```

.claude/skills/ha-integration/DEVICE.MD

@@ -1,248 +0,0 @@
-# Device Management Reference
-
-Device management groups entities and provides device information.
-
-## Device Info
-
-```python
-from homeassistant.helpers.device_registry import DeviceInfo
-
-from .const import DOMAIN
-
-
-class MyEntity(CoordinatorEntity[MyCoordinator]):
-    """Base entity with device info."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, coordinator.client.serial_number)},
-            name=coordinator.client.name,
-            manufacturer="My Company",
-            model=coordinator.client.model,
-            sw_version=coordinator.client.firmware_version,
-            hw_version=coordinator.client.hardware_version,
-        )
-```
-
-## DeviceInfo Fields
-
-| Field | Description | Example |
-|-------|-------------|---------|
-| `identifiers` | Set of (domain, id) tuples | `{(DOMAIN, "ABC123")}` |
-| `connections` | Set of (type, id) tuples | `{(CONNECTION_NETWORK_MAC, mac)}` |
-| `name` | Device name | `"Living Room Thermostat"` |
-| `manufacturer` | Manufacturer name | `"My Company"` |
-| `model` | Model name | `"Smart Thermostat v2"` |
-| `model_id` | Model identifier | `"THM-2000"` |
-| `sw_version` | Software/firmware version | `"1.2.3"` |
-| `hw_version` | Hardware version | `"rev2"` |
-| `serial_number` | Serial number | `"ABC123456"` |
-| `configuration_url` | Device config URL | `"http://192.168.1.100"` |
-| `suggested_area` | Suggested room/area | `"Living Room"` |
-| `entry_type` | Device entry type | `DeviceEntryType.SERVICE` |
-| `via_device` | Parent device identifiers | `(DOMAIN, "hub_id")` |
-
-## Device with Connections
-
-Use connections (like MAC address) for better device merging:
-
-```python
-from homeassistant.helpers.device_registry import (
-    CONNECTION_NETWORK_MAC,
-    DeviceInfo,
-    format_mac,
-)
-
-
-def __init__(self, coordinator: MyCoordinator) -> None:
-    """Initialize the entity."""
-    super().__init__(coordinator)
-    self._attr_device_info = DeviceInfo(
-        connections={(CONNECTION_NETWORK_MAC, format_mac(coordinator.client.mac))},
-        identifiers={(DOMAIN, coordinator.client.serial_number)},
-        name=coordinator.client.name,
-        manufacturer="My Company",
-        model=coordinator.client.model,
-    )
-```
-
-## Hub and Child Devices
-
-```python
-# Hub device
-class HubEntity(CoordinatorEntity[MyCoordinator]):
-    """Hub entity."""
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the hub entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, coordinator.hub_id)},
-            name="My Hub",
-            manufacturer="My Company",
-            model="Hub Pro",
-        )
-
-
-# Child device connected via hub
-class ChildEntity(CoordinatorEntity[MyCoordinator]):
-    """Child device entity."""
-
-    def __init__(self, coordinator: MyCoordinator, device: ChildDevice) -> None:
-        """Initialize the child entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, device.id)},
-            name=device.name,
-            manufacturer="My Company",
-            model=device.model,
-            via_device=(DOMAIN, coordinator.hub_id),  # Links to parent hub
-        )
-```
-
-## Service Entry Type
-
-For cloud services without physical devices:
-
-```python
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-
-
-self._attr_device_info = DeviceInfo(
-    identifiers={(DOMAIN, entry.entry_id)},
-    name="My Cloud Service",
-    manufacturer="My Company",
-    entry_type=DeviceEntryType.SERVICE,
-)
-```
-
-## Dynamic Device Addition
-
-Auto-detect new devices after initial setup:
-
-```python
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up sensors from config entry."""
-    coordinator = entry.runtime_data
-    known_devices: set[str] = set()
-
-    @callback
-    def _check_devices() -> None:
-        """Check for new devices."""
-        current_devices = set(coordinator.data.devices.keys())
-        new_devices = current_devices - known_devices
-
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                MySensor(coordinator, device_id)
-                for device_id in new_devices
-            )
-
-    # Initial setup
-    _check_devices()
-
-    # Listen for updates
-    entry.async_on_unload(coordinator.async_add_listener(_check_devices))
-```
-
-## Stale Device Removal
-
-Remove devices when they disappear:
-
-```python
-async def _async_update_data(self) -> MyData:
-    """Fetch data and handle device removal."""
-    data = await self.client.get_data()
-
-    # Check for removed devices
-    device_registry = dr.async_get(self.hass)
-    current_device_ids = set(data.devices.keys())
-
-    for device_entry in dr.async_entries_for_config_entry(
-        device_registry, self.config_entry.entry_id
-    ):
-        # Get device ID from identifiers
-        device_id = next(
-            (id for domain, id in device_entry.identifiers if domain == DOMAIN),
-            None,
-        )
-
-        if device_id and device_id not in current_device_ids:
-            # Device no longer exists, remove it
-            device_registry.async_update_device(
-                device_entry.id,
-                remove_config_entry_id=self.config_entry.entry_id,
-            )
-
-    return data
-```
-
-## Manual Device Removal
-
-Allow users to manually remove devices:
-
-```python
-# In __init__.py
-
-async def async_remove_config_entry_device(
-    hass: HomeAssistant, config_entry: MyIntegrationConfigEntry, device_entry: dr.DeviceEntry
-) -> bool:
-    """Remove a config entry from a device."""
-    # Get device ID from identifiers
-    device_id = next(
-        (id for domain, id in device_entry.identifiers if domain == DOMAIN),
-        None,
-    )
-
-    if device_id is None:
-        return False
-
-    # Check if device is still present (don't allow removal of active devices)
-    coordinator = config_entry.runtime_data
-    if device_id in coordinator.data.devices:
-        return False  # Device still exists, can't remove
-
-    return True  # Allow removal of stale device
-```
-
-## Device Registry Access
-
-```python
-from homeassistant.helpers import device_registry as dr
-
-
-# Get device registry
-device_registry = dr.async_get(hass)
-
-# Get device by identifiers
-device = device_registry.async_get_device(
-    identifiers={(DOMAIN, device_id)}
-)
-
-# Get all devices for config entry
-devices = dr.async_entries_for_config_entry(
-    device_registry, entry.entry_id
-)
-
-# Update device
-device_registry.async_update_device(
-    device.id,
-    sw_version="2.0.0",
-)
-```
-
-## Quality Scale Requirements
-
-- **Bronze**: No specific device requirements
-- **Gold**: Devices rule - group entities under devices
-- **Gold**: Stale device removal - auto-remove disconnected devices
-- **Gold**: Dynamic device addition - detect new devices at runtime

.claude/skills/ha-integration/DIAGNOSTICS.MD

@@ -1,278 +0,0 @@
-# Diagnostics Reference
-
-Diagnostics provide debug information for troubleshooting integrations.
-
-## Basic Diagnostics
-
-```python
-"""Diagnostics support for My Integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_TOKEN
-from homeassistant.core import HomeAssistant
-
-from . import MyIntegrationConfigEntry
-
-TO_REDACT = {
-    CONF_API_KEY,
-    CONF_PASSWORD,
-    CONF_TOKEN,
-    "serial_number",
-    "mac_address",
-    "latitude",
-    "longitude",
-}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: MyIntegrationConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-
-    return {
-        "entry_data": async_redact_data(dict(entry.data), TO_REDACT),
-        "entry_options": async_redact_data(dict(entry.options), TO_REDACT),
-        "coordinator_data": async_redact_data(
-            coordinator.data.to_dict(), TO_REDACT
-        ),
-    }
-```
-
-## What to Include
-
-**Do include:**
-- Configuration data (redacted)
-- Current coordinator data
-- Device information
-- Error states and counts
-- Connection status
-- Firmware versions
-- Feature flags
-
-**Never include (always redact):**
-- API keys, tokens, passwords
-- Geographic coordinates (latitude/longitude)
-- Personal identifiable information
-- Email addresses
-- MAC addresses (unless needed for debugging)
-- Serial numbers (unless needed for debugging)
-
-## Comprehensive Diagnostics
-
-```python
-"""Diagnostics support for My Integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import (
-    CONF_API_KEY,
-    CONF_LATITUDE,
-    CONF_LONGITUDE,
-    CONF_PASSWORD,
-    CONF_TOKEN,
-    CONF_USERNAME,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr, entity_registry as er
-
-from . import MyIntegrationConfigEntry
-from .const import DOMAIN
-
-TO_REDACT = {
-    CONF_API_KEY,
-    CONF_LATITUDE,
-    CONF_LONGITUDE,
-    CONF_PASSWORD,
-    CONF_TOKEN,
-    CONF_USERNAME,
-    "serial",
-    "serial_number",
-    "mac",
-    "mac_address",
-    "email",
-    "access_token",
-    "refresh_token",
-}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: MyIntegrationConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-
-    # Get device registry entries
-    device_registry = dr.async_get(hass)
-    entity_registry = er.async_get(hass)
-
-    devices = []
-    for device in dr.async_entries_for_config_entry(device_registry, entry.entry_id):
-        entities = []
-        for entity in er.async_entries_for_device(
-            entity_registry, device.id, include_disabled_entities=True
-        ):
-            entities.append({
-                "entity_id": entity.entity_id,
-                "unique_id": entity.unique_id,
-                "platform": entity.platform,
-                "disabled": entity.disabled,
-                "disabled_by": entity.disabled_by,
-            })
-
-        devices.append({
-            "name": device.name,
-            "model": device.model,
-            "manufacturer": device.manufacturer,
-            "sw_version": device.sw_version,
-            "hw_version": device.hw_version,
-            "identifiers": list(device.identifiers),
-            "connections": list(device.connections),
-            "entities": entities,
-        })
-
-    return {
-        "entry": {
-            "version": entry.version,
-            "minor_version": entry.minor_version,
-            "data": async_redact_data(dict(entry.data), TO_REDACT),
-            "options": async_redact_data(dict(entry.options), TO_REDACT),
-        },
-        "coordinator": {
-            "last_update_success": coordinator.last_update_success,
-            "last_exception": str(coordinator.last_exception) if coordinator.last_exception else None,
-            "data": async_redact_data(coordinator.data.to_dict(), TO_REDACT),
-        },
-        "devices": devices,
-    }
-```
-
-## Device-Level Diagnostics
-
-For integrations with multiple devices, you can also provide device-level diagnostics:
-
-```python
-async def async_get_device_diagnostics(
-    hass: HomeAssistant, entry: MyIntegrationConfigEntry, device: dr.DeviceEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a device."""
-    coordinator = entry.runtime_data
-
-    # Find device data based on device identifiers
-    device_id = next(
-        (id for domain, id in device.identifiers if domain == DOMAIN), None
-    )
-
-    if device_id is None:
-        return {"error": "Device not found"}
-
-    device_data = coordinator.data.devices.get(device_id)
-    if device_data is None:
-        return {"error": "Device data not found"}
-
-    return {
-        "device_info": {
-            "name": device.name,
-            "model": device.model,
-            "sw_version": device.sw_version,
-        },
-        "device_data": async_redact_data(device_data.to_dict(), TO_REDACT),
-    }
-```
-
-## Redaction Patterns
-
-### Simple Redaction
-
-```python
-from homeassistant.components.diagnostics import async_redact_data
-
-data = {"api_key": "secret123", "temperature": 21.5}
-redacted = async_redact_data(data, {"api_key"})
-# Result: {"api_key": "**REDACTED**", "temperature": 21.5}
-```
-
-### Nested Redaction
-
-`async_redact_data` handles nested dictionaries automatically:
-
-```python
-data = {
-    "config": {
-        "host": "192.168.1.1",
-        "api_key": "secret123",
-    },
-    "device": {
-        "name": "My Device",
-        "serial_number": "ABC123",
-    }
-}
-redacted = async_redact_data(data, {"api_key", "serial_number"})
-# Result: {"config": {"host": "192.168.1.1", "api_key": "**REDACTED**"},
-#          "device": {"name": "My Device", "serial_number": "**REDACTED**"}}
-```
-
-### Custom Redaction
-
-For complex redaction needs:
-
-```python
-def _redact_data(data: dict[str, Any]) -> dict[str, Any]:
-    """Redact sensitive data."""
-    result = dict(data)
-
-    # Redact specific keys
-    for key in ("api_key", "token", "password"):
-        if key in result:
-            result[key] = "**REDACTED**"
-
-    # Redact partial data (e.g., keep last 4 chars)
-    if "serial" in result:
-        result["serial"] = f"****{result['serial'][-4:]}"
-
-    # Redact coordinates to city level
-    if "latitude" in result:
-        result["latitude"] = round(result["latitude"], 1)
-    if "longitude" in result:
-        result["longitude"] = round(result["longitude"], 1)
-
-    return result
-```
-
-## Testing Diagnostics
-
-```python
-from homeassistant.components.diagnostics import REDACTED
-
-from custom_components.my_integration.diagnostics import (
-    async_get_config_entry_diagnostics,
-)
-
-
-async def test_diagnostics(
-    hass: HomeAssistant,
-    init_integration: MockConfigEntry,
-) -> None:
-    """Test diagnostics."""
-    diagnostics = await async_get_config_entry_diagnostics(hass, init_integration)
-
-    assert diagnostics["entry"]["data"]["host"] == "192.168.1.1"
-    assert diagnostics["entry"]["data"]["api_key"] == REDACTED
-    assert "temperature" in diagnostics["coordinator"]["data"]
-```
-
-## Quality Scale Requirement
-
-Diagnostics are required for **Gold** quality scale and above. Ensure your `quality_scale.yaml` includes:
-
-```yaml
-rules:
-  diagnostics: done
-```

.claude/skills/ha-integration/ENTITY.MD

@@ -1,286 +0,0 @@
-# Entity Development Reference
-
-Base patterns for entity development in Home Assistant.
-
-## Base Entity Class
-
-Create a shared base class to reduce duplication:
-
-```python
-"""Base entity for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import MyCoordinator
-
-
-class MyEntity(CoordinatorEntity[MyCoordinator]):
-    """Base entity for My Integration."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
-```
-
-## Unique IDs
-
-Every entity must have a unique ID:
-
-```python
-class MySensor(MyEntity, SensorEntity):
-    """Sensor entity."""
-
-    def __init__(self, coordinator: MyCoordinator, sensor_type: str) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        # Unique per platform, don't include domain or platform name
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{sensor_type}"
-```
-
-**Acceptable unique ID sources:**
-- Device serial numbers
-- MAC addresses (use `format_mac` from device registry)
-- Physical identifiers
-
-**Never use:**
-- IP addresses, hostnames, URLs
-- Device names
-- Email addresses, usernames
-
-## Entity Naming
-
-```python
-class MySensor(MyEntity, SensorEntity):
-    """Sensor with proper naming."""
-
-    _attr_has_entity_name = True
-    _attr_translation_key = "temperature"  # Translatable name
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        # For the main/primary entity of a device, use None
-        # self._attr_name = None
-
-        # For secondary entities, set the name
-        self._attr_name = "Temperature"  # Or use translation_key
-```
-
-## Entity Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "sensor": {
-      "temperature": {
-        "name": "Temperature"
-      },
-      "humidity": {
-        "name": "Humidity"
-      },
-      "battery": {
-        "name": "Battery",
-        "state": {
-          "charging": "Charging",
-          "discharging": "Discharging"
-        }
-      }
-    }
-  }
-}
-```
-
-## Entity Availability
-
-### Coordinator Pattern
-
-```python
-@property
-def available(self) -> bool:
-    """Return if entity is available."""
-    return super().available and self._sensor_key in self.coordinator.data.sensors
-```
-
-### Direct Update Pattern
-
-```python
-async def async_update(self) -> None:
-    """Update entity state."""
-    try:
-        data = await self.client.get_data()
-    except MyException:
-        self._attr_available = False
-        return
-
-    self._attr_available = True
-    self._attr_native_value = data.value
-```
-
-## Entity Categories
-
-```python
-from homeassistant.const import EntityCategory
-
-
-class DiagnosticSensor(MyEntity, SensorEntity):
-    """Diagnostic sensor (hidden by default in UI)."""
-
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-
-
-class ConfigSwitch(MyEntity, SwitchEntity):
-    """Configuration switch."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-```
-
-## Disabled by Default
-
-For noisy or less popular entities:
-
-```python
-class SignalStrengthSensor(MyEntity, SensorEntity):
-    """Signal strength sensor - disabled by default."""
-
-    _attr_entity_registry_enabled_default = False
-```
-
-## Event Lifecycle
-
-```python
-class MyEntity(CoordinatorEntity[MyCoordinator]):
-    """Entity with event subscriptions."""
-
-    async def async_added_to_hass(self) -> None:
-        """Subscribe to events when added."""
-        await super().async_added_to_hass()
-        self.async_on_remove(
-            self.coordinator.client.events.subscribe(
-                "state_changed",
-                self._handle_state_change,
-            )
-        )
-
-    @callback
-    def _handle_state_change(self, event: Event) -> None:
-        """Handle state change event."""
-        self._attr_native_value = event.value
-        self.async_write_ha_state()
-```
-
-**Key rules:**
-- Subscribe in `async_added_to_hass`
-- Use `async_on_remove` for automatic cleanup
-- Never subscribe in `__init__`
-
-## State Handling
-
-```python
-@property
-def native_value(self) -> StateType:
-    """Return the state."""
-    value = self.coordinator.data.get(self._key)
-    # Use None for unknown values, never "unknown" or "unavailable" strings
-    if value is None:
-        return None
-    return value
-```
-
-## Extra State Attributes
-
-```python
-@property
-def extra_state_attributes(self) -> dict[str, Any]:
-    """Return extra state attributes."""
-    data = self.coordinator.data
-    # All keys must always be present, use None for unknown
-    return {
-        "last_updated": data.last_updated,
-        "error_count": data.error_count,
-        "firmware": data.firmware or None,  # Never omit keys
-    }
-```
-
-## Entity Descriptions Pattern
-
-For multiple similar entities:
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable
-
-from homeassistant.components.sensor import SensorEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySensorEntityDescription(SensorEntityDescription):
-    """Describe My sensor entity."""
-
-    value_fn: Callable[[MyData], StateType]
-
-
-SENSOR_DESCRIPTIONS: tuple[MySensorEntityDescription, ...] = (
-    MySensorEntityDescription(
-        key="temperature",
-        translation_key="temperature",
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        device_class=SensorDeviceClass.TEMPERATURE,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.temperature,
-    ),
-    MySensorEntityDescription(
-        key="humidity",
-        translation_key="humidity",
-        native_unit_of_measurement=PERCENTAGE,
-        device_class=SensorDeviceClass.HUMIDITY,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.humidity,
-    ),
-)
-
-
-class MySensor(MyEntity, SensorEntity):
-    """Sensor using entity description."""
-
-    entity_description: MySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySensorEntityDescription,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the sensor value."""
-        return self.entity_description.value_fn(self.coordinator.data)
-```
-
-## Multiline Lambdas
-
-When lambdas are too long:
-
-```python
-# Good pattern - parentheses on same line as lambda
-MySensorEntityDescription(
-    key="temperature",
-    value_fn=lambda data: (
-        round(data["temp_value"] * 1.8 + 32, 1)
-        if data.get("temp_value") is not None
-        else None
-    ),
-)
-```

.claude/skills/ha-integration/NUMBER.MD

@@ -1,229 +0,0 @@
-# Number Platform Reference
-
-Number entities represent numeric values that can be set.
-
-## Basic Number
-
-```python
-"""Number platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.number import NumberEntity, NumberMode
-from homeassistant.const import UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up numbers from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        TargetTemperatureNumber(coordinator),
-    ])
-
-
-class TargetTemperatureNumber(MyEntity, NumberEntity):
-    """Target temperature number entity."""
-
-    _attr_native_min_value = 16
-    _attr_native_max_value = 30
-    _attr_native_step = 0.5
-    _attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
-    _attr_mode = NumberMode.SLIDER
-    _attr_translation_key = "target_temperature"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the number entity."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_target_temp"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the current value."""
-        return self.coordinator.data.target_temperature
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set the target temperature."""
-        await self.coordinator.client.set_target_temperature(value)
-        await self.coordinator.async_request_refresh()
-```
-
-## Number Modes
-
-```python
-from homeassistant.components.number import NumberMode
-
-# Slider display in UI
-_attr_mode = NumberMode.SLIDER
-
-# Input box display in UI
-_attr_mode = NumberMode.BOX
-
-# Auto (slider if range <= 256, else box)
-_attr_mode = NumberMode.AUTO
-```
-
-## Device Classes
-
-```python
-from homeassistant.components.number import NumberDeviceClass
-
-# For temperature settings
-_attr_device_class = NumberDeviceClass.TEMPERATURE
-
-# Other device classes
-NumberDeviceClass.HUMIDITY
-NumberDeviceClass.POWER
-NumberDeviceClass.VOLTAGE
-NumberDeviceClass.CURRENT
-```
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.number import NumberEntityDescription, NumberMode
-
-
-@dataclass(frozen=True, kw_only=True)
-class MyNumberEntityDescription(NumberEntityDescription):
-    """Describe My number entity."""
-
-    value_fn: Callable[[MyData], float | None]
-    set_value_fn: Callable[[MyClient, float], Coroutine[Any, Any, None]]
-
-
-NUMBERS: tuple[MyNumberEntityDescription, ...] = (
-    MyNumberEntityDescription(
-        key="target_temperature",
-        translation_key="target_temperature",
-        native_min_value=16,
-        native_max_value=30,
-        native_step=0.5,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        mode=NumberMode.SLIDER,
-        value_fn=lambda data: data.target_temperature,
-        set_value_fn=lambda client, value: client.set_target_temperature(value),
-    ),
-    MyNumberEntityDescription(
-        key="brightness",
-        translation_key="brightness",
-        native_min_value=0,
-        native_max_value=100,
-        native_step=1,
-        native_unit_of_measurement=PERCENTAGE,
-        mode=NumberMode.SLIDER,
-        entity_category=EntityCategory.CONFIG,
-        value_fn=lambda data: data.brightness,
-        set_value_fn=lambda client, value: client.set_brightness(int(value)),
-    ),
-)
-
-
-class MyNumber(MyEntity, NumberEntity):
-    """Number using entity description."""
-
-    entity_description: MyNumberEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MyNumberEntityDescription,
-    ) -> None:
-        """Initialize the number entity."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the current value."""
-        return self.entity_description.value_fn(self.coordinator.data)
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set the value."""
-        await self.entity_description.set_value_fn(self.coordinator.client, value)
-        await self.coordinator.async_request_refresh()
-```
-
-## Dynamic Min/Max Values
-
-```python
-class DynamicRangeNumber(MyEntity, NumberEntity):
-    """Number with dynamic range based on device capabilities."""
-
-    _attr_translation_key = "fan_speed"
-
-    @property
-    def native_min_value(self) -> float:
-        """Return minimum value."""
-        return self.coordinator.data.fan_speed_min
-
-    @property
-    def native_max_value(self) -> float:
-        """Return maximum value."""
-        return self.coordinator.data.fan_speed_max
-
-    @property
-    def native_step(self) -> float:
-        """Return step value."""
-        return self.coordinator.data.fan_speed_step or 1
-```
-
-## Configuration Number
-
-```python
-class ConfigNumber(MyEntity, NumberEntity):
-    """Configuration number entity."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_native_min_value = 1
-    _attr_native_max_value = 60
-    _attr_native_step = 1
-    _attr_native_unit_of_measurement = "min"
-    _attr_translation_key = "timeout"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the timeout setting."""
-        return self.coordinator.data.timeout_minutes
-
-    async def async_set_native_value(self, value: float) -> None:
-        """Set the timeout."""
-        await self.coordinator.client.set_timeout(int(value))
-        await self.coordinator.async_request_refresh()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "number": {
-      "target_temperature": {
-        "name": "Target temperature"
-      },
-      "brightness": {
-        "name": "Brightness"
-      },
-      "timeout": {
-        "name": "Timeout"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/SELECT.MD

@@ -1,252 +0,0 @@
-# Select Platform Reference
-
-Select entities allow choosing from a predefined list of options.
-
-## Basic Select
-
-```python
-"""Select platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.select import SelectEntity
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up selects from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        ModeSelect(coordinator),
-    ])
-
-
-class ModeSelect(MyEntity, SelectEntity):
-    """Mode select entity."""
-
-    _attr_options = ["auto", "cool", "heat", "fan_only", "dry"]
-    _attr_translation_key = "mode"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the select entity."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_mode"
-
-    @property
-    def current_option(self) -> str | None:
-        """Return the current option."""
-        return self.coordinator.data.mode
-
-    async def async_select_option(self, option: str) -> None:
-        """Change the selected option."""
-        await self.coordinator.client.set_mode(option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.select import SelectEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySelectEntityDescription(SelectEntityDescription):
-    """Describe My select entity."""
-
-    current_option_fn: Callable[[MyData], str | None]
-    select_option_fn: Callable[[MyClient, str], Coroutine[Any, Any, None]]
-
-
-SELECTS: tuple[MySelectEntityDescription, ...] = (
-    MySelectEntityDescription(
-        key="mode",
-        translation_key="mode",
-        options=["auto", "cool", "heat", "fan_only", "dry"],
-        current_option_fn=lambda data: data.mode,
-        select_option_fn=lambda client, option: client.set_mode(option),
-    ),
-    MySelectEntityDescription(
-        key="fan_speed",
-        translation_key="fan_speed",
-        options=["low", "medium", "high", "auto"],
-        entity_category=EntityCategory.CONFIG,
-        current_option_fn=lambda data: data.fan_speed,
-        select_option_fn=lambda client, option: client.set_fan_speed(option),
-    ),
-)
-
-
-class MySelect(MyEntity, SelectEntity):
-    """Select using entity description."""
-
-    entity_description: MySelectEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySelectEntityDescription,
-    ) -> None:
-        """Initialize the select entity."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def options(self) -> list[str]:
-        """Return available options."""
-        return list(self.entity_description.options)
-
-    @property
-    def current_option(self) -> str | None:
-        """Return current option."""
-        return self.entity_description.current_option_fn(self.coordinator.data)
-
-    async def async_select_option(self, option: str) -> None:
-        """Select an option."""
-        await self.entity_description.select_option_fn(self.coordinator.client, option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Dynamic Options
-
-```python
-class DynamicSelect(MyEntity, SelectEntity):
-    """Select with options from device."""
-
-    _attr_translation_key = "preset"
-
-    @property
-    def options(self) -> list[str]:
-        """Return available presets from device."""
-        return self.coordinator.data.available_presets
-
-    @property
-    def current_option(self) -> str | None:
-        """Return current preset."""
-        return self.coordinator.data.current_preset
-
-    async def async_select_option(self, option: str) -> None:
-        """Select a preset."""
-        await self.coordinator.client.set_preset(option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Configuration Select
-
-```python
-class ConfigSelect(MyEntity, SelectEntity):
-    """Configuration select (settings)."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_options = ["silent", "normal", "boost"]
-    _attr_translation_key = "performance_mode"
-
-    @property
-    def current_option(self) -> str | None:
-        """Return current performance mode."""
-        return self.coordinator.data.performance_mode
-
-    async def async_select_option(self, option: str) -> None:
-        """Set performance mode."""
-        await self.coordinator.client.set_performance_mode(option)
-        await self.coordinator.async_request_refresh()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "select": {
-      "mode": {
-        "name": "Mode",
-        "state": {
-          "auto": "Auto",
-          "cool": "Cool",
-          "heat": "Heat",
-          "fan_only": "Fan only",
-          "dry": "Dry"
-        }
-      },
-      "fan_speed": {
-        "name": "Fan speed",
-        "state": {
-          "low": "Low",
-          "medium": "Medium",
-          "high": "High",
-          "auto": "Auto"
-        }
-      },
-      "performance_mode": {
-        "name": "Performance mode",
-        "state": {
-          "silent": "Silent",
-          "normal": "Normal",
-          "boost": "Boost"
-        }
-      }
-    }
-  }
-}
-```
-
-## Icon by State
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "select": {
-      "mode": {
-        "name": "Mode",
-        "default": "mdi:thermostat",
-        "state": {
-          "auto": "Auto",
-          "cool": "Cool",
-          "heat": "Heat"
-        },
-        "state_icons": {
-          "auto": "mdi:thermostat-auto",
-          "cool": "mdi:snowflake",
-          "heat": "mdi:fire"
-        }
-      }
-    }
-  }
-}
-```
-
-Note: State icons are defined in `icons.json`:
-
-```json
-{
-  "entity": {
-    "select": {
-      "mode": {
-        "default": "mdi:thermostat",
-        "state": {
-          "auto": "mdi:thermostat-auto",
-          "cool": "mdi:snowflake",
-          "heat": "mdi:fire"
-        }
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/SENSOR.MD

@@ -1,271 +0,0 @@
-# Sensor Platform Reference
-
-Sensors represent read-only values from devices.
-
-## Basic Sensor
-
-```python
-"""Sensor platform for My Integration."""
-
-from __future__ import annotations
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorStateClass,
-)
-from homeassistant.const import UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up sensors from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        TemperatureSensor(coordinator),
-        HumiditySensor(coordinator),
-    ])
-
-
-class TemperatureSensor(MyEntity, SensorEntity):
-    """Temperature sensor."""
-
-    _attr_device_class = SensorDeviceClass.TEMPERATURE
-    _attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
-    _attr_state_class = SensorStateClass.MEASUREMENT
-    _attr_translation_key = "temperature"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_temperature"
-
-    @property
-    def native_value(self) -> float | None:
-        """Return the temperature."""
-        return self.coordinator.data.temperature
-```
-
-## Device Classes
-
-Common sensor device classes:
-
-| Device Class | Unit Examples | Use Case |
-|--------------|---------------|----------|
-| `TEMPERATURE` | °C, °F | Temperature readings |
-| `HUMIDITY` | % | Humidity levels |
-| `PRESSURE` | hPa, mbar | Atmospheric pressure |
-| `BATTERY` | % | Battery level |
-| `POWER` | W, kW | Power consumption |
-| `ENERGY` | Wh, kWh | Energy usage |
-| `VOLTAGE` | V | Electrical voltage |
-| `CURRENT` | A, mA | Electrical current |
-| `CO2` | ppm | Carbon dioxide |
-| `PM25` | µg/m³ | Particulate matter |
-
-## State Classes
-
-```python
-from homeassistant.components.sensor import SensorStateClass
-
-# For instantaneous values that can go up or down
-_attr_state_class = SensorStateClass.MEASUREMENT
-
-# For ever-increasing totals (like energy consumption)
-_attr_state_class = SensorStateClass.TOTAL
-
-# For totals that reset periodically
-_attr_state_class = SensorStateClass.TOTAL_INCREASING
-```
-
-## Entity Description Pattern
-
-For multiple sensors with similar structure:
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable
-from typing import Any
-
-from homeassistant.components.sensor import SensorEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySensorEntityDescription(SensorEntityDescription):
-    """Describe My sensor entity."""
-
-    value_fn: Callable[[MyData], Any]
-
-
-SENSORS: tuple[MySensorEntityDescription, ...] = (
-    MySensorEntityDescription(
-        key="temperature",
-        translation_key="temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.temperature,
-    ),
-    MySensorEntityDescription(
-        key="humidity",
-        translation_key="humidity",
-        device_class=SensorDeviceClass.HUMIDITY,
-        native_unit_of_measurement=PERCENTAGE,
-        state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda data: data.humidity,
-    ),
-    MySensorEntityDescription(
-        key="signal_strength",
-        translation_key="signal_strength",
-        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
-        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
-        state_class=SensorStateClass.MEASUREMENT,
-        entity_category=EntityCategory.DIAGNOSTIC,
-        entity_registry_enabled_default=False,  # Disabled by default
-        value_fn=lambda data: data.rssi,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up sensors from config entry."""
-    coordinator = entry.runtime_data
-    async_add_entities(
-        MySensor(coordinator, description)
-        for description in SENSORS
-    )
-
-
-class MySensor(MyEntity, SensorEntity):
-    """Sensor using entity description."""
-
-    entity_description: MySensorEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySensorEntityDescription,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def native_value(self) -> StateType:
-        """Return the sensor value."""
-        return self.entity_description.value_fn(self.coordinator.data)
-```
-
-## Suggested Display Precision
-
-```python
-# Control decimal places shown in UI
-_attr_suggested_display_precision = 1  # Show 21.5 instead of 21.456789
-```
-
-## Timestamp Sensors
-
-```python
-from datetime import datetime
-
-from homeassistant.components.sensor import SensorDeviceClass
-
-
-class LastUpdatedSensor(MyEntity, SensorEntity):
-    """Last updated timestamp sensor."""
-
-    _attr_device_class = SensorDeviceClass.TIMESTAMP
-    _attr_translation_key = "last_updated"
-
-    @property
-    def native_value(self) -> datetime | None:
-        """Return the last update timestamp."""
-        return self.coordinator.data.last_updated
-```
-
-## Enum Sensors
-
-```python
-from homeassistant.components.sensor import SensorDeviceClass
-
-
-class StatusSensor(MyEntity, SensorEntity):
-    """Status sensor with enum values."""
-
-    _attr_device_class = SensorDeviceClass.ENUM
-    _attr_options = ["idle", "running", "error", "offline"]
-    _attr_translation_key = "status"
-
-    @property
-    def native_value(self) -> str | None:
-        """Return the current status."""
-        return self.coordinator.data.status
-```
-
-With translations in `strings.json`:
-
-```json
-{
-  "entity": {
-    "sensor": {
-      "status": {
-        "name": "Status",
-        "state": {
-          "idle": "Idle",
-          "running": "Running",
-          "error": "Error",
-          "offline": "Offline"
-        }
-      }
-    }
-  }
-}
-```
-
-## Dynamic Icons
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "sensor": {
-      "battery_level": {
-        "name": "Battery level",
-        "default": "mdi:battery-unknown",
-        "range": {
-          "0": "mdi:battery-outline",
-          "10": "mdi:battery-10",
-          "50": "mdi:battery-50",
-          "90": "mdi:battery-90",
-          "100": "mdi:battery"
-        }
-      }
-    }
-  }
-}
-```
-
-## PARALLEL_UPDATES
-
-```python
-# At module level - limit concurrent updates
-PARALLEL_UPDATES = 1  # Serialize to prevent overwhelming device
-
-# Or unlimited for coordinator-based platforms
-PARALLEL_UPDATES = 0
-```

.claude/skills/ha-integration/SERVICES.MD

@@ -1,335 +0,0 @@
-# Services Reference
-
-Services allow automations and users to trigger actions.
-
-## Service Registration
-
-Register services in `async_setup`, NOT in `async_setup_entry`:
-
-```python
-"""My Integration setup."""
-
-from __future__ import annotations
-
-from typing import Any
-
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigEntry, ConfigEntryState
-from homeassistant.const import ATTR_DEVICE_ID
-from homeassistant.core import HomeAssistant, ServiceCall, ServiceResponse, SupportsResponse
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import config_validation as cv, device_registry as dr
-
-from .const import ATTR_CONFIG_ENTRY_ID, DOMAIN
-
-SERVICE_REFRESH = "refresh"
-SERVICE_SET_SCHEDULE = "set_schedule"
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up My Integration services."""
-
-    async def handle_refresh(call: ServiceCall) -> None:
-        """Handle refresh service call."""
-        entry_id = call.data[ATTR_CONFIG_ENTRY_ID]
-
-        if not (entry := hass.config_entries.async_get_entry(entry_id)):
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_found",
-            )
-
-        if entry.state is not ConfigEntryState.LOADED:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_loaded",
-            )
-
-        coordinator = entry.runtime_data
-        await coordinator.async_request_refresh()
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_REFRESH,
-        handle_refresh,
-        schema=vol.Schema({
-            vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string,
-        }),
-    )
-
-    return True
-```
-
-## Service with Response
-
-```python
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up services with response."""
-
-    async def handle_get_schedule(call: ServiceCall) -> ServiceResponse:
-        """Handle get_schedule service call."""
-        entry_id = call.data[ATTR_CONFIG_ENTRY_ID]
-
-        if not (entry := hass.config_entries.async_get_entry(entry_id)):
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_found",
-            )
-
-        if entry.state is not ConfigEntryState.LOADED:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="entry_not_loaded",
-            )
-
-        coordinator = entry.runtime_data
-        schedule = await coordinator.client.get_schedule()
-
-        return {
-            "schedule": [
-                {"day": item.day, "start": item.start, "end": item.end}
-                for item in schedule
-            ]
-        }
-
-    hass.services.async_register(
-        DOMAIN,
-        "get_schedule",
-        handle_get_schedule,
-        schema=vol.Schema({
-            vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string,
-        }),
-        supports_response=SupportsResponse.ONLY,  # or SupportsResponse.OPTIONAL
-    )
-
-    return True
-```
-
-## Entity Services
-
-Register entity-specific services in platform setup:
-
-```python
-"""Switch platform with entity service."""
-
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-import voluptuous as vol
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up switches from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([PowerSwitch(coordinator)])
-
-    # Register entity service
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        "set_timer",
-        {
-            vol.Required("minutes"): vol.All(
-                vol.Coerce(int), vol.Range(min=1, max=120)
-            ),
-        },
-        "async_set_timer",
-    )
-
-
-class PowerSwitch(MyEntity, SwitchEntity):
-    """Power switch with timer service."""
-
-    async def async_set_timer(self, minutes: int) -> None:
-        """Set auto-off timer."""
-        await self.coordinator.client.set_timer(minutes)
-```
-
-## Service Validation
-
-```python
-from homeassistant.exceptions import ServiceValidationError
-
-
-async def handle_set_schedule(call: ServiceCall) -> None:
-    """Handle set_schedule service call."""
-    start_date = call.data["start_date"]
-    end_date = call.data["end_date"]
-
-    # Validate input
-    if end_date < start_date:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="end_date_before_start_date",
-        )
-
-    entry_id = call.data[ATTR_CONFIG_ENTRY_ID]
-    entry = hass.config_entries.async_get_entry(entry_id)
-
-    try:
-        await entry.runtime_data.client.set_schedule(start_date, end_date)
-    except MyConnectionError as err:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="connection_failed",
-        ) from err
-```
-
-## services.yaml
-
-Define services in `services.yaml`:
-
-```yaml
-refresh:
-  name: Refresh
-  description: Force a data refresh from the device.
-  fields:
-    config_entry_id:
-      name: Config entry ID
-      description: The config entry to refresh.
-      required: true
-      selector:
-        config_entry:
-          integration: my_integration
-
-set_schedule:
-  name: Set schedule
-  description: Set the device schedule.
-  fields:
-    config_entry_id:
-      name: Config entry ID
-      description: The config entry to configure.
-      required: true
-      selector:
-        config_entry:
-          integration: my_integration
-    start_date:
-      name: Start date
-      description: Schedule start date.
-      required: true
-      selector:
-        date:
-    end_date:
-      name: End date
-      description: Schedule end date.
-      required: true
-      selector:
-        date:
-
-get_schedule:
-  name: Get schedule
-  description: Get the current device schedule.
-  fields:
-    config_entry_id:
-      name: Config entry ID
-      description: The config entry to query.
-      required: true
-      selector:
-        config_entry:
-          integration: my_integration
-
-set_timer:
-  name: Set timer
-  description: Set auto-off timer for the switch.
-  target:
-    entity:
-      integration: my_integration
-      domain: switch
-  fields:
-    minutes:
-      name: Minutes
-      description: Timer duration in minutes.
-      required: true
-      selector:
-        number:
-          min: 1
-          max: 120
-          unit_of_measurement: min
-```
-
-## Exception Translations
-
-In `strings.json`:
-
-```json
-{
-  "exceptions": {
-    "entry_not_found": {
-      "message": "Config entry not found."
-    },
-    "entry_not_loaded": {
-      "message": "Config entry is not loaded."
-    },
-    "end_date_before_start_date": {
-      "message": "The end date cannot be before the start date."
-    },
-    "connection_failed": {
-      "message": "Failed to connect to the device."
-    }
-  }
-}
-```
-
-## Device-Based Service Targeting
-
-```python
-async def handle_device_service(call: ServiceCall) -> None:
-    """Handle service call targeting a device."""
-    device_id = call.data[ATTR_DEVICE_ID]
-
-    device_registry = dr.async_get(hass)
-    device = device_registry.async_get(device_id)
-
-    if device is None:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="device_not_found",
-        )
-
-    # Find config entry for device
-    entry_id = next(
-        (entry_id for entry_id in device.config_entries if entry_id),
-        None,
-    )
-
-    if entry_id is None:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="entry_not_found",
-        )
-
-    entry = hass.config_entries.async_get_entry(entry_id)
-    # ... continue with service logic
-```
-
-## Service Schema Patterns
-
-```python
-import voluptuous as vol
-from homeassistant.helpers import config_validation as cv
-
-# Basic schema
-SERVICE_SCHEMA = vol.Schema({
-    vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string,
-    vol.Required("value"): vol.All(vol.Coerce(int), vol.Range(min=0, max=100)),
-    vol.Optional("timeout", default=30): cv.positive_int,
-})
-
-# With entity targeting
-SERVICE_SCHEMA_ENTITY = vol.Schema({
-    vol.Required("entity_id"): cv.entity_ids,
-    vol.Required("parameter"): cv.string,
-})
-
-# With selectors (for services.yaml)
-# Use selector in services.yaml, not in Python schema
-```
-
-## Quality Scale Requirements
-
-- **Bronze**: `action-setup` - Register services in `async_setup` if integration has services
-- Services must validate config entry state before use
-- Use translated exceptions for error messages

.claude/skills/ha-integration/SKILL.md

@@ -1,165 +0,0 @@
----
-name: ha-integration
-description: Develop Home Assistant integrations following best practices. Use when creating, modifying, or reviewing integration code including config flows, entities, coordinators, diagnostics, services, and tests.
----
-
-# Home Assistant Integration Development
-
-You are developing a Home Assistant integration. Follow these guidelines and reference the supporting documentation for specific components.
-
-## Quick Reference
-
-| Component | Reference File |
-|-----------|----------------|
-| Config flow | [CONFIG-FLOW.MD](CONFIG-FLOW.MD) |
-| Data coordinator | [COORDINATOR.MD](COORDINATOR.MD) |
-| Entities (base) | [ENTITY.MD](ENTITY.MD) |
-| Sensors | [SENSOR.MD](SENSOR.MD) |
-| Binary sensors | [BINARY-SENSOR.MD](BINARY-SENSOR.MD) |
-| Switches | [SWITCH.MD](SWITCH.MD) |
-| Numbers | [NUMBER.MD](NUMBER.MD) |
-| Selects | [SELECT.MD](SELECT.MD) |
-| Buttons | [BUTTON.MD](BUTTON.MD) |
-| Device management | [DEVICE.MD](DEVICE.MD) |
-| Diagnostics | [DIAGNOSTICS.MD](DIAGNOSTICS.MD) |
-| Services | [SERVICES.MD](SERVICES.MD) |
-| Testing | [TESTING.MD](TESTING.MD) |
-
-## Integration Structure
-
-```
-homeassistant/components/my_integration/
-├── __init__.py          # Entry point with async_setup_entry
-├── manifest.json        # Integration metadata and dependencies
-├── const.py            # Domain and constants
-├── config_flow.py      # UI configuration flow
-├── coordinator.py      # Data update coordinator
-├── entity.py          # Base entity class
-├── sensor.py          # Sensor platform
-├── diagnostics.py     # Diagnostic data collection
-├── strings.json        # User-facing text and translations
-├── services.yaml       # Service definitions (if applicable)
-└── quality_scale.yaml  # Quality scale rule status
-```
-
-## Quality Scale Levels
-
-- **Bronze**: Basic requirements (ALL Bronze rules are mandatory)
-- **Silver**: Enhanced functionality (entity unavailability, parallel updates, auth flows)
-- **Gold**: Advanced features (device management, diagnostics, translations)
-- **Platinum**: Highest quality (strict typing, async dependencies, websession injection)
-
-Check `manifest.json` for `"quality_scale"` key and `quality_scale.yaml` for rule status.
-
-## Core Patterns
-
-### Entry Point (`__init__.py`)
-
-```python
-"""Integration for My Device."""
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-
-from .const import DOMAIN
-from .coordinator import MyCoordinator
-
-PLATFORMS = [Platform.SENSOR, Platform.BINARY_SENSOR]
-
-type MyIntegrationConfigEntry = ConfigEntry[MyCoordinator]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: MyIntegrationConfigEntry) -> bool:
-    """Set up My Integration from a config entry."""
-    coordinator = MyCoordinator(hass, entry)
-    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: MyIntegrationConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-```
-
-### Constants (`const.py`)
-
-```python
-"""Constants for My Integration."""
-
-DOMAIN = "my_integration"
-```
-
-### Manifest (`manifest.json`)
-
-```json
-{
-  "domain": "my_integration",
-  "name": "My Integration",
-  "codeowners": ["@username"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/my_integration",
-  "integration_type": "hub",
-  "iot_class": "local_polling",
-  "requirements": ["my-library==1.0.0"],
-  "quality_scale": "bronze"
-}
-```
-
-## Python Requirements
-
-- **Compatibility**: Python 3.13+
-- **Type hints**: Required for all functions and methods
-- **f-strings**: Preferred over `%` or `.format()`
-- **Async**: All external I/O must be async
-
-## Code Quality
-
-- **Formatting**: Ruff
-- **Linting**: PyLint and Ruff
-- **Type Checking**: MyPy
-- **Testing**: pytest with >95% coverage
-
-## Common Anti-Patterns to Avoid
-
-```python
-# Blocking operations
-data = requests.get(url)  # Use async or executor
-time.sleep(5)  # Use asyncio.sleep()
-
-# Hardcoded strings
-self._attr_name = "Temperature"  # Use translation_key
-
-# Too much in try block
-try:
-    data = await client.get_data()
-    processed = data["value"] * 100  # Move outside try
-except Error:
-    pass
-
-# User-configurable polling
-vol.Optional("scan_interval"): cv.positive_int  # Not allowed
-```
-
-## Development Commands
-
-```bash
-# Run tests with coverage
-pytest ./tests/components/<domain> \
-  --cov=homeassistant.components.<domain> \
-  --cov-report term-missing \
-  --numprocesses=auto
-
-# Type checking
-mypy homeassistant/components/<domain>
-
-# Linting
-pylint homeassistant/components/<domain>
-
-# Validate integration
-python -m script.hassfest --integration-path homeassistant/components/<domain>
-```

.claude/skills/ha-integration/SWITCH.MD

@@ -1,236 +0,0 @@
-# Switch Platform Reference
-
-Switches control on/off functionality.
-
-## Basic Switch
-
-```python
-"""Switch platform for My Integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.switch import SwitchEntity, SwitchDeviceClass
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
-
-from . import MyIntegrationConfigEntry
-from .entity import MyEntity
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: MyIntegrationConfigEntry,
-    async_add_entities: AddEntitiesCallback,
-) -> None:
-    """Set up switches from config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities([
-        PowerSwitch(coordinator),
-    ])
-
-
-class PowerSwitch(MyEntity, SwitchEntity):
-    """Power switch."""
-
-    _attr_device_class = SwitchDeviceClass.SWITCH
-    _attr_translation_key = "power"
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{coordinator.client.serial_number}_power"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if switch is on."""
-        return self.coordinator.data.is_on
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        await self.coordinator.client.turn_on()
-        await self.coordinator.async_request_refresh()
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
-        await self.coordinator.client.turn_off()
-        await self.coordinator.async_request_refresh()
-```
-
-## Device Classes
-
-| Device Class | Use Case |
-|--------------|----------|
-| `OUTLET` | Electrical outlet |
-| `SWITCH` | Generic switch |
-
-## Entity Description Pattern
-
-```python
-from dataclasses import dataclass
-from collections.abc import Callable, Coroutine
-from typing import Any
-
-from homeassistant.components.switch import SwitchEntityDescription
-
-
-@dataclass(frozen=True, kw_only=True)
-class MySwitchEntityDescription(SwitchEntityDescription):
-    """Describe My switch entity."""
-
-    is_on_fn: Callable[[MyData], bool | None]
-    turn_on_fn: Callable[[MyClient], Coroutine[Any, Any, None]]
-    turn_off_fn: Callable[[MyClient], Coroutine[Any, Any, None]]
-
-
-SWITCHES: tuple[MySwitchEntityDescription, ...] = (
-    MySwitchEntityDescription(
-        key="power",
-        translation_key="power",
-        device_class=SwitchDeviceClass.SWITCH,
-        is_on_fn=lambda data: data.is_on,
-        turn_on_fn=lambda client: client.turn_on(),
-        turn_off_fn=lambda client: client.turn_off(),
-    ),
-    MySwitchEntityDescription(
-        key="child_lock",
-        translation_key="child_lock",
-        entity_category=EntityCategory.CONFIG,
-        is_on_fn=lambda data: data.child_lock_enabled,
-        turn_on_fn=lambda client: client.set_child_lock(True),
-        turn_off_fn=lambda client: client.set_child_lock(False),
-    ),
-)
-
-
-class MySwitch(MyEntity, SwitchEntity):
-    """Switch using entity description."""
-
-    entity_description: MySwitchEntityDescription
-
-    def __init__(
-        self,
-        coordinator: MyCoordinator,
-        description: MySwitchEntityDescription,
-    ) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.client.serial_number}_{description.key}"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if switch is on."""
-        return self.entity_description.is_on_fn(self.coordinator.data)
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        await self.entity_description.turn_on_fn(self.coordinator.client)
-        await self.coordinator.async_request_refresh()
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
-        await self.entity_description.turn_off_fn(self.coordinator.client)
-        await self.coordinator.async_request_refresh()
-```
-
-## Configuration Switch
-
-```python
-class ConfigSwitch(MyEntity, SwitchEntity):
-    """Configuration switch (e.g., enable/disable a feature)."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_translation_key = "auto_mode"
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true if auto mode is enabled."""
-        return self.coordinator.data.auto_mode_enabled
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Enable auto mode."""
-        await self.coordinator.client.set_auto_mode(True)
-        await self.coordinator.async_request_refresh()
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Disable auto mode."""
-        await self.coordinator.client.set_auto_mode(False)
-        await self.coordinator.async_request_refresh()
-```
-
-## Optimistic Updates
-
-For devices with slow response:
-
-```python
-class OptimisticSwitch(MyEntity, SwitchEntity):
-    """Switch with optimistic state updates."""
-
-    _attr_assumed_state = True  # Indicates state may not be accurate
-
-    def __init__(self, coordinator: MyCoordinator) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self._optimistic_state: bool | None = None
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return optimistic state if set, otherwise coordinator state."""
-        if self._optimistic_state is not None:
-            return self._optimistic_state
-        return self.coordinator.data.is_on
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn on with optimistic update."""
-        self._optimistic_state = True
-        self.async_write_ha_state()
-        try:
-            await self.coordinator.client.turn_on()
-        finally:
-            self._optimistic_state = None
-            await self.coordinator.async_request_refresh()
-```
-
-## Error Handling
-
-```python
-from homeassistant.exceptions import HomeAssistantError
-
-
-class RobustSwitch(MyEntity, SwitchEntity):
-    """Switch with proper error handling."""
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        try:
-            await self.coordinator.client.turn_on()
-        except MyDeviceError as err:
-            raise HomeAssistantError(f"Failed to turn on: {err}") from err
-
-        await self.coordinator.async_request_refresh()
-```
-
-## Translations
-
-In `strings.json`:
-
-```json
-{
-  "entity": {
-    "switch": {
-      "power": {
-        "name": "Power"
-      },
-      "child_lock": {
-        "name": "Child lock"
-      },
-      "auto_mode": {
-        "name": "Auto mode"
-      }
-    }
-  }
-}
-```

.claude/skills/ha-integration/TESTING.MD

@@ -1,396 +0,0 @@
-# Testing Reference
-
-Testing patterns for Home Assistant integrations.
-
-## Test Structure
-
-```
-tests/components/my_integration/
-├── __init__.py
-├── conftest.py              # Shared fixtures
-├── test_config_flow.py      # Config flow tests (100% coverage required)
-├── test_init.py             # Integration setup tests
-├── test_sensor.py           # Sensor platform tests
-├── test_diagnostics.py      # Diagnostics tests
-├── snapshots/               # Snapshot files
-│   └── test_sensor.ambr
-└── fixtures/                # Test data fixtures
-    └── device_data.json
-```
-
-## conftest.py
-
-```python
-"""Fixtures for My Integration tests."""
-
-from collections.abc import Generator
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from homeassistant.components.my_integration.const import DOMAIN
-from homeassistant.const import CONF_API_KEY, CONF_HOST, Platform
-from homeassistant.core import HomeAssistant
-
-from tests.common import MockConfigEntry, load_fixture
-
-
-@pytest.fixture
-def mock_config_entry() -> MockConfigEntry:
-    """Return the default mocked config entry."""
-    return MockConfigEntry(
-        domain=DOMAIN,
-        title="My Device",
-        data={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_api_key",
-        },
-        unique_id="device_serial_123",
-    )
-
-
-@pytest.fixture
-def mock_client() -> Generator[MagicMock]:
-    """Return a mocked client."""
-    with patch(
-        "homeassistant.components.my_integration.MyClient",
-        autospec=True,
-    ) as client_mock:
-        client = client_mock.return_value
-        client.get_data = AsyncMock(
-            return_value=MyData.from_json(load_fixture("device_data.json", DOMAIN))
-        )
-        client.serial_number = "device_serial_123"
-        client.name = "My Device"
-        client.model = "Model X"
-        client.firmware_version = "1.2.3"
-        yield client
-
-
-@pytest.fixture
-def platforms() -> list[Platform]:
-    """Return platforms to test."""
-    return [Platform.SENSOR, Platform.BINARY_SENSOR]
-
-
-@pytest.fixture
-async def init_integration(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_client: MagicMock,
-    platforms: list[Platform],
-) -> MockConfigEntry:
-    """Set up the integration for testing."""
-    mock_config_entry.add_to_hass(hass)
-
-    with patch(
-        "homeassistant.components.my_integration.PLATFORMS",
-        platforms,
-    ):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
-    return mock_config_entry
-```
-
-## Config Flow Tests
-
-**100% coverage required for all paths:**
-
-```python
-"""Test config flow for My Integration."""
-
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from homeassistant.components.my_integration.const import DOMAIN
-from homeassistant.config_entries import SOURCE_USER, SOURCE_ZEROCONF
-from homeassistant.const import CONF_API_KEY, CONF_HOST
-from homeassistant.core import HomeAssistant
-from homeassistant.data_entry_flow import FlowResultType
-
-from tests.common import MockConfigEntry
-
-
-async def test_user_flow_success(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test successful user flow."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "user"
-    assert result["errors"] == {}
-
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_key",
-        },
-    )
-
-    assert result["type"] is FlowResultType.CREATE_ENTRY
-    assert result["title"] == "My Device"
-    assert result["data"] == {
-        CONF_HOST: "192.168.1.100",
-        CONF_API_KEY: "test_key",
-    }
-    assert result["result"].unique_id == "device_serial_123"
-
-
-async def test_user_flow_cannot_connect(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test connection error in user flow."""
-    mock_client.get_data.side_effect = ConnectionError("Cannot connect")
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_key",
-        },
-    )
-
-    assert result["type"] is FlowResultType.FORM
-    assert result["errors"] == {"base": "cannot_connect"}
-
-
-async def test_user_flow_already_configured(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_client: AsyncMock,
-) -> None:
-    """Test already configured error."""
-    mock_config_entry.add_to_hass(hass)
-
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN, context={"source": SOURCE_USER}
-    )
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={
-            CONF_HOST: "192.168.1.100",
-            CONF_API_KEY: "test_key",
-        },
-    )
-
-    assert result["type"] is FlowResultType.ABORT
-    assert result["reason"] == "already_configured"
-
-
-async def test_reauth_flow(
-    hass: HomeAssistant,
-    mock_config_entry: MockConfigEntry,
-    mock_client: AsyncMock,
-) -> None:
-    """Test reauthentication flow."""
-    mock_config_entry.add_to_hass(hass)
-
-    result = await mock_config_entry.start_reauth_flow(hass)
-    assert result["type"] is FlowResultType.FORM
-    assert result["step_id"] == "reauth_confirm"
-
-    result = await hass.config_entries.flow.async_configure(
-        result["flow_id"],
-        user_input={CONF_API_KEY: "new_api_key"},
-    )
-
-    assert result["type"] is FlowResultType.ABORT
-    assert result["reason"] == "reauth_successful"
-    assert mock_config_entry.data[CONF_API_KEY] == "new_api_key"
-```
-
-## Entity Tests with Snapshots
-
-```python
-"""Test sensor platform."""
-
-import pytest
-from syrupy.assertion import SnapshotAssertion
-
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import device_registry as dr, entity_registry as er
-
-from tests.common import MockConfigEntry, snapshot_platform
-
-
-@pytest.fixture
-def platforms() -> list[Platform]:
-    """Override platforms for sensor tests."""
-    return [Platform.SENSOR]
-
-
-@pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
-async def test_sensors(
-    hass: HomeAssistant,
-    snapshot: SnapshotAssertion,
-    entity_registry: er.EntityRegistry,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test sensor entities."""
-    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
-
-
-@pytest.mark.usefixtures("init_integration")
-async def test_sensor_device_assignment(
-    hass: HomeAssistant,
-    device_registry: dr.DeviceRegistry,
-    entity_registry: er.EntityRegistry,
-    mock_config_entry: MockConfigEntry,
-) -> None:
-    """Test sensors are assigned to correct device."""
-    device = device_registry.async_get_device(
-        identifiers={("my_integration", "device_serial_123")}
-    )
-    assert device is not None
-
-    entities = er.async_entries_for_config_entry(
-        entity_registry, mock_config_entry.entry_id
-    )
-    for entity in entities:
-        assert entity.device_id == device.id
-```
-
-## Coordinator Tests
-
-```python
-"""Test coordinator."""
-
-from unittest.mock import AsyncMock
-
-import pytest
-
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import UpdateFailed
-
-
-async def test_coordinator_update_success(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test successful coordinator update."""
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-    await coordinator.async_refresh()
-
-    assert coordinator.data.temperature == 21.5
-    assert coordinator.last_update_success
-
-
-async def test_coordinator_update_failed(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test coordinator handles API error."""
-    mock_client.get_data.side_effect = MyError("Connection failed")
-
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-
-    with pytest.raises(UpdateFailed):
-        await coordinator._async_update_data()
-
-
-async def test_coordinator_auth_failed(
-    hass: HomeAssistant,
-    mock_client: AsyncMock,
-) -> None:
-    """Test coordinator handles auth error."""
-    mock_client.get_data.side_effect = AuthError("Invalid token")
-
-    coordinator = MyCoordinator(hass, mock_config_entry, mock_client)
-
-    with pytest.raises(ConfigEntryAuthFailed):
-        await coordinator._async_update_data()
-```
-
-## Diagnostics Tests
-
-```python
-"""Test diagnostics."""
-
-from homeassistant.components.diagnostics import REDACTED
-from homeassistant.core import HomeAssistant
-
-from tests.common import MockConfigEntry
-from tests.components.my_integration import snapshot_platform
-from tests.typing import ClientSessionGenerator
-
-
-async def test_diagnostics(
-    hass: HomeAssistant,
-    hass_client: ClientSessionGenerator,
-    init_integration: MockConfigEntry,
-    snapshot: SnapshotAssertion,
-) -> None:
-    """Test diagnostics."""
-    assert await get_diagnostics_for_config_entry(
-        hass, hass_client, init_integration
-    ) == snapshot
-```
-
-## Common Fixtures
-
-```python
-from tests.common import MockConfigEntry, load_fixture
-
-# Load JSON fixture
-data = load_fixture("device_data.json", DOMAIN)
-
-# Enable all entities (including disabled by default)
-@pytest.mark.usefixtures("entity_registry_enabled_by_default")
-
-# Freeze time
-from freezegun.api import FrozenDateTimeFactory
-
-async def test_with_frozen_time(
-    hass: HomeAssistant,
-    freezer: FrozenDateTimeFactory,
-) -> None:
-    freezer.tick(timedelta(minutes=5))
-    await hass.async_block_till_done()
-```
-
-## Update Snapshots
-
-```bash
-# Update snapshots
-pytest tests/components/my_integration --snapshot-update
-
-# Always re-run without flag to verify
-pytest tests/components/my_integration
-```
-
-## Test Commands
-
-```bash
-# Run tests with coverage
-pytest tests/components/my_integration \
-  --cov=homeassistant.components.my_integration \
-  --cov-report term-missing \
-  --numprocesses=auto
-
-# Run specific test
-pytest tests/components/my_integration/test_config_flow.py::test_user_flow_success
-
-# Quick test of changed files
-pytest --timeout=10 --picked
-```
-
-## Best Practices
-
-1. **Never access `hass.data` directly** - Use fixtures and proper setup
-2. **Mock all external APIs** - Use fixtures with realistic JSON data
-3. **Use snapshot testing** - For entity states and attributes
-4. **Test error paths** - Connection errors, auth failures, invalid data
-5. **Test edge cases** - Empty data, missing fields, None values
-6. **>95% coverage required** - All code paths must be tested

.core_files.yaml

@@ -13,7 +13,6 @@ core: &core
 
 # Our base platforms, that are used by other integrations
 base_platforms: &base_platforms
-  - homeassistant/components/ai_task/**
   - homeassistant/components/air_quality/**
   - homeassistant/components/alarm_control_panel/**
   - homeassistant/components/assist_satellite/**
@@ -59,7 +58,6 @@ base_platforms: &base_platforms
 # Extra components that trigger the full suite
 components: &components
   - homeassistant/components/alexa/**
-  - homeassistant/components/analytics/**
   - homeassistant/components/application_credentials/**
   - homeassistant/components/assist_pipeline/**
   - homeassistant/components/auth/**
@@ -91,7 +89,6 @@ components: &components
   - homeassistant/components/input_number/**
   - homeassistant/components/input_select/**
   - homeassistant/components/input_text/**
-  - homeassistant/components/labs/**
   - homeassistant/components/logbook/**
   - homeassistant/components/logger/**
   - homeassistant/components/lovelace/**

.devcontainer/devcontainer.json

@@ -8,8 +8,6 @@
     "PYTHONASYNCIODEBUG": "1"
   },
   "features": {
-    // Node feature required for Claude Code until fixed https://github.com/anthropics/devcontainer-features/issues/28
-    "ghcr.io/devcontainers/features/node:1": {},
     "ghcr.io/anthropics/devcontainer-features/claude-code:1.0": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}
   },
@@ -27,12 +25,13 @@
         "charliermarsh.ruff",
         "ms-python.pylint",
         "ms-python.vscode-pylance",
+        "visualstudioexptteam.vscodeintellicode",
         "redhat.vscode-yaml",
         "esbenp.prettier-vscode",
         "GitHub.vscode-pull-request-github",
         "GitHub.copilot"
       ],
-      // Please keep this file in sync with settings in home-assistant/.vscode/settings.default.jsonc
+      // Please keep this file in sync with settings in home-assistant/.vscode/settings.default.json
       "settings": {
         "python.experiments.optOutFrom": ["pythonTestAdapter"],
         "python.defaultInterpreterPath": "/home/vscode/.local/ha-venv/bin/python",
@@ -40,8 +39,6 @@
         "python.terminal.activateEnvInCurrentTerminal": true,
         "python.testing.pytestArgs": ["--no-cov"],
         "pylint.importStrategy": "fromEnvironment",
-        // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
-        "python.analysis.typeCheckingMode": "off",
         "editor.formatOnPaste": false,
         "editor.formatOnSave": true,
         "editor.formatOnType": true,
@@ -63,9 +60,6 @@
         "[python]": {
           "editor.defaultFormatter": "charliermarsh.ruff"
         },
-        "[json][jsonc][yaml]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
         "json.schemas": [
           {
             "fileMatch": ["homeassistant/components/*/manifest.json"],

.dockerignore

@@ -14,8 +14,7 @@ tests
 
 # Other virtualization methods
 venv
-.venv
 .vagrant
 
 # Temporary files
-**/__pycache__
+**/__pycache__

.github/PULL_REQUEST_TEMPLATE.md

@@ -55,12 +55,8 @@
   creating the PR. If you're unsure about any of them, don't hesitate to ask.
   We're here to help! This is simply a reminder of what we are going to look
   for before merging your code.
-
-  AI tools are welcome, but contributors are responsible for *fully*
-  understanding the code before submitting a PR.
 -->
 
-- [ ] I understand the code I am submitting and can explain how it works.
 - [ ] The code change is tested and works locally.
 - [ ] Local tests pass. **Your PR cannot be merged unless tests pass**
 - [ ] There is no commented out code in this PR.
@@ -68,7 +64,6 @@
 - [ ] I have followed the [perfect PR recommendations][perfect-pr]
 - [ ] The code has been formatted using Ruff (`ruff format homeassistant tests`)
 - [ ] Tests have been added to verify that the new code works.
-- [ ] Any generated code has been carefully reviewed for correctness and compliance with project standards.
 
 If user exposed functionality or configuration variables are added/changed:
 

.github/copilot-instructions.md

@@ -51,9 +51,6 @@ rules:
 - **Missing imports** - We use static analysis tooling to catch that
 - **Code formatting** - We have ruff as a formatting tool that will catch those if needed (unless specifically instructed otherwise in these instructions)
 
-**Git commit practices during review:**
-- **Do NOT amend, squash, or rebase commits after review has started** - Reviewers need to see what changed since their last review
-
 ## Python Requirements
 
 - **Compatibility**: Python 3.13+
@@ -77,7 +74,6 @@ rules:
 - **Formatting**: Ruff
 - **Linting**: PyLint and Ruff
 - **Type Checking**: MyPy
-- **Lint/Type/Format Fixes**: Always prefer addressing the underlying issue (e.g., import the typed source, update shared stubs, align with Ruff expectations, or correct formatting at the source) before disabling a rule, adding `# type: ignore`, or skipping a formatter. Treat suppressions and `noqa` comments as a last resort once no compliant fix exists
 - **Testing**: pytest with plain functions and fixtures
 - **Language**: American English for all code, comments, and documentation (use sentence case, including titles)
 
@@ -847,8 +843,8 @@ rules:
 ## Development Commands
 
 ### Code Quality & Linting
-- **Run all linters on all files**: `prek run --all-files`
-- **Run linters on staged files only**: `prek run`
+- **Run all linters on all files**: `pre-commit run --all-files`
+- **Run linters on staged files only**: `pre-commit run`
 - **PyLint on everything** (slow): `pylint homeassistant`
 - **PyLint on specific folder**: `pylint homeassistant/components/my_integration`
 - **MyPy type checking (whole project)**: `mypy homeassistant/`
@@ -1024,6 +1020,18 @@ class MyCoordinator(DataUpdateCoordinator[MyData]):
         )
 ```
 
+### Entity Performance Optimization
+```python
+# Use __slots__ for memory efficiency
+class MySensor(SensorEntity):
+    __slots__ = ("_attr_native_value", "_attr_available")
+    
+    @property 
+    def should_poll(self) -> bool:
+        """Disable polling when using coordinator."""
+        return False  # ✅ Let coordinator handle updates
+```
+
 ## Testing Patterns
 
 ### Testing Best Practices
@@ -1065,11 +1073,7 @@ async def test_flow_connection_error(hass, mock_api_error):
 
 ### Entity Testing Patterns
 ```python
-@pytest.fixture 
-def platforms() -> list[Platform]: 
-    """Overridden fixture to specify platforms to test.""" 
-    return [Platform.SENSOR]  # Or another specific platform as needed.
-
+@pytest.mark.parametrize("init_integration", [Platform.SENSOR], indirect=True)
 @pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
 async def test_entities(
     hass: HomeAssistant,
@@ -1116,25 +1120,16 @@ def mock_device_api() -> Generator[MagicMock]:
         )
         yield api
 
-@pytest.fixture 
-def platforms() -> list[Platform]: 
-    """Fixture to specify platforms to test.""" 
-    return PLATFORMS
-
 @pytest.fixture
 async def init_integration(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
     mock_device_api: MagicMock,
-    platforms: list[Platform],
 ) -> MockConfigEntry:
     """Set up the integration for testing."""
     mock_config_entry.add_to_hass(hass)
-    
-    with patch("homeassistant.components.my_integration.PLATFORMS", platforms):
-        await hass.config_entries.async_setup(mock_config_entry.entry_id)
-        await hass.async_block_till_done()
-
+    await hass.config_entries.async_setup(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
     return mock_config_entry
 ```
 
@@ -1169,4 +1164,4 @@ python -m script.hassfest --integration-path homeassistant/components/my_integra
 pytest ./tests/components/my_integration \
   --cov=homeassistant.components.my_integration \
   --cov-report term-missing
-```
+```

.github/workflows/builder.yml

@@ -14,9 +14,6 @@ env:
   PIP_TIMEOUT: 60
   UV_HTTP_TIMEOUT: 60
   UV_SYSTEM_PYTHON: "true"
-  # Base image version from https://github.com/home-assistant/docker
-  BASE_IMAGE_VERSION: "2025.12.0"
-  ARCHITECTURES: '["amd64", "aarch64"]'
 
 jobs:
   init:
@@ -24,16 +21,18 @@ jobs:
     if: github.repository_owner == 'home-assistant'
     runs-on: ubuntu-latest
     outputs:
+      architectures: ${{ steps.info.outputs.architectures }}
       version: ${{ steps.version.outputs.version }}
       channel: ${{ steps.version.outputs.channel }}
       publish: ${{ steps.version.outputs.publish }}
-      architectures: ${{ env.ARCHITECTURES }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v5.0.0
+        with:
+          fetch-depth: 0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -70,7 +69,7 @@ jobs:
         run: find ./homeassistant/components/*/translations -name "*.json" | tar zcvf translations.tar.gz -T -
 
       - name: Upload translations
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@v4.6.2
         with:
           name: translations
           path: translations.tar.gz
@@ -80,7 +79,7 @@ jobs:
     name: Build ${{ matrix.arch }} base core image
     if: github.repository_owner == 'home-assistant'
     needs: init
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
@@ -89,18 +88,13 @@ jobs:
       fail-fast: false
       matrix:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
-        include:
-          - arch: amd64
-            os: ubuntu-latest
-          - arch: aarch64
-            os: ubuntu-24.04-arm
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v5.0.0
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        uses: dawidd6/action-download-artifact@v11
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -111,7 +105,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        uses: dawidd6/action-download-artifact@v11
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: OHF-Voice/intents-package
@@ -122,7 +116,7 @@ jobs:
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         if: needs.init.outputs.channel == 'dev'
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -168,8 +162,20 @@ jobs:
             sed -i "s|home-assistant-intents==.*||" requirements_all.txt
           fi
 
+      - name: Adjustments for armhf
+        if: matrix.arch == 'armhf'
+        run: |
+          # Pandas has issues building on armhf, it is expected they
+          # will drop the platform in the near future (they consider it
+          # "flimsy" on 386). The following packages depend on pandas,
+          # so we comment them out.
+          sed -i "s|env-canada|# env-canada|g" requirements_all.txt
+          sed -i "s|noaa-coops|# noaa-coops|g" requirements_all.txt
+          sed -i "s|pyezviz|# pyezviz|g" requirements_all.txt
+          sed -i "s|pykrakenapi|# pykrakenapi|g" requirements_all.txt
+
       - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@v5.0.0
         with:
           name: translations
 
@@ -184,66 +190,21 @@ jobs:
           echo "${{ github.sha }};${{ github.ref }};${{ github.event_name }};${{ github.actor }}" > rootfs/OFFICIAL_IMAGE
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@v3.5.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - &install_cosign
-        name: Install Cosign
-        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
-        with:
-          cosign-release: "v2.5.3"
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
-
-      - name: Build variables
-        id: vars
-        shell: bash
-        run: |
-          echo "base_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ env.BASE_IMAGE_VERSION }}" >> "$GITHUB_OUTPUT"
-          echo "cache_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:latest" >> "$GITHUB_OUTPUT"
-          echo "created=$(date --rfc-3339=seconds --utc)" >> "$GITHUB_OUTPUT"
-
-      - name: Verify base image signature
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/docker/.*" \
-            "${{ steps.vars.outputs.base_image }}"
-
-      - name: Verify cache image signature
-        id: cache
-        continue-on-error: true
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
-            "${{ steps.vars.outputs.cache_image }}"
-
       - name: Build base image
-        id: build
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+        uses: home-assistant/builder@2025.03.0
         with:
-          context: .
-          file: ./Dockerfile
-          platforms: ${{ steps.vars.outputs.platform }}
-          push: true
-          cache-from: ${{ steps.cache.outcome == 'success' && steps.vars.outputs.cache_image || '' }}
-          build-args: |
-            BUILD_FROM=${{ steps.vars.outputs.base_image }}
-          tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          labels: |
-            io.hass.arch=${{ matrix.arch }}
-            io.hass.version=${{ needs.init.outputs.version }}
-            org.opencontainers.image.created=${{ steps.vars.outputs.created }}
-            org.opencontainers.image.version=${{ needs.init.outputs.version }}
-
-      - name: Sign image
-        run: |
-          cosign sign --yes "ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}@${{ steps.build.outputs.digest }}"
+          args: |
+            $BUILD_ARGS \
+            --${{ matrix.arch }} \
+            --cosign \
+            --target /data \
+            --generic ${{ needs.init.outputs.version }}
 
   build_machine:
     name: Build ${{ matrix.machine }} machine core image
@@ -264,16 +225,24 @@ jobs:
           - odroid-c4
           - odroid-m1
           - odroid-n2
+          - odroid-xu
+          - qemuarm
           - qemuarm-64
+          - qemux86
           - qemux86-64
+          - raspberrypi
+          - raspberrypi2
+          - raspberrypi3
           - raspberrypi3-64
+          - raspberrypi4
           - raspberrypi4-64
           - raspberrypi5-64
+          - tinker
           - yellow
           - green
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v5.0.0
 
       - name: Set build additional args
         run: |
@@ -287,15 +256,14 @@ jobs:
           fi
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@v3.5.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      # home-assistant/builder doesn't support sha pinning
       - name: Build base image
-        uses: home-assistant/builder@2025.11.0
+        uses: home-assistant/builder@2025.03.0
         with:
           args: |
             $BUILD_ARGS \
@@ -311,7 +279,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v5.0.0
 
       - name: Initialize git
         uses: home-assistant/actions/helpers/git-init@master
@@ -327,7 +295,6 @@ jobs:
           key-description: "Home Assistant Core"
           version: ${{ needs.init.outputs.version }}
           channel: ${{ needs.init.outputs.channel }}
-          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
 
       - name: Update version file (stable -> beta)
         if: needs.init.outputs.channel == 'stable'
@@ -337,7 +304,6 @@ jobs:
           key-description: "Home Assistant Core"
           version: ${{ needs.init.outputs.version }}
           channel: beta
-          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
 
   publish_container:
     name: Publish meta container for ${{ matrix.registry }}
@@ -354,114 +320,128 @@ jobs:
       matrix:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
-      - *install_cosign
+      - name: Checkout the repository
+        uses: actions/checkout@v5.0.0
+
+      - name: Install Cosign
+        uses: sigstore/cosign-installer@v3.9.2
+        with:
+          cosign-release: "v2.2.3"
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@v3.5.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        if: matrix.registry == 'ghcr.io/home-assistant'
+        uses: docker/login-action@v3.5.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Verify architecture image signatures
+      - name: Build Meta Image
         shell: bash
         run: |
-          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
-          for arch in $ARCHS; do
-            echo "Verifying ${arch} image signature..."
-            cosign verify \
-              --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-              --certificate-identity-regexp https://github.com/home-assistant/core/.* \
-              "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
-          done
-          echo "✓ All images verified successfully"
+          export DOCKER_CLI_EXPERIMENTAL=enabled
 
-      # Generate all Docker tags based on version string
-      # Version format: YYYY.MM.PATCH, YYYY.MM.PATCHbN (beta), or YYYY.MM.PATCH.devYYYYMMDDHHMM (dev)
-      # Examples:
-      #   2025.12.1     (stable)    -> tags: 2025.12.1, 2025.12, stable, latest, beta, rc
-      #   2025.12.0b3   (beta)      -> tags: 2025.12.0b3, beta, rc
-      #   2025.12.0.dev202511250240 -> tags: 2025.12.0.dev202511250240, dev
-      - name: Generate Docker metadata
-        id: meta
-        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
-        with:
-          images: ${{ matrix.registry }}/home-assistant
-          sep-tags: ","
-          tags: |
-            type=raw,value=${{ needs.init.outputs.version }},priority=9999
-            type=raw,value=dev,enable=${{ contains(needs.init.outputs.version, 'd') }}
-            type=raw,value=beta,enable=${{ !contains(needs.init.outputs.version, 'd') }}
-            type=raw,value=rc,enable=${{ !contains(needs.init.outputs.version, 'd') }}
-            type=raw,value=stable,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
-            type=raw,value=latest,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
-            type=semver,pattern={{major}}.{{minor}},value=${{ needs.init.outputs.version }},enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
+          function create_manifest() {
+            local tag_l=${1}
+            local tag_r=${2}
+            local registry=${{ matrix.registry }}
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.7.1
+            docker manifest create "${registry}/home-assistant:${tag_l}" \
+              "${registry}/amd64-homeassistant:${tag_r}" \
+              "${registry}/i386-homeassistant:${tag_r}" \
+              "${registry}/armhf-homeassistant:${tag_r}" \
+              "${registry}/armv7-homeassistant:${tag_r}" \
+              "${registry}/aarch64-homeassistant:${tag_r}"
 
-      - name: Copy architecture images to DockerHub
-        if: matrix.registry == 'docker.io/homeassistant'
-        shell: bash
-        run: |
-          # Use imagetools to copy image blobs directly between registries
-          # This preserves provenance/attestations and seems to be much faster than pull/push
-          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
-          for arch in $ARCHS; do
-            echo "Copying ${arch} image to DockerHub..."
-            for attempt in 1 2 3; do
-              if docker buildx imagetools create \
-                --tag "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}" \
-                "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"; then
-                break
-              fi
-              echo "Attempt ${attempt} failed, retrying in 10 seconds..."
-              sleep 10
-              if [ "${attempt}" -eq 3 ]; then
-                echo "Failed after 3 attempts"
-                exit 1
-              fi
-            done
-            cosign sign --yes "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
-          done
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/amd64-homeassistant:${tag_r}" \
+              --os linux --arch amd64
 
-      - name: Create and push multi-arch manifests
-        shell: bash
-        run: |
-          # Build list of architecture images dynamically
-          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
-          ARCH_IMAGES=()
-          for arch in $ARCHS; do
-            ARCH_IMAGES+=("${{ matrix.registry }}/${arch}-homeassistant:${{ needs.init.outputs.version }}")
-          done
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/i386-homeassistant:${tag_r}" \
+              --os linux --arch 386
 
-          # Build list of all tags for single manifest creation
-          # Note: Using sep-tags=',' in metadata-action for easier parsing
-          TAG_ARGS=()
-          IFS=',' read -ra TAGS <<< "${{ steps.meta.outputs.tags }}"
-          for tag in "${TAGS[@]}"; do
-            TAG_ARGS+=("--tag" "${tag}")
-          done
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/armhf-homeassistant:${tag_r}" \
+              --os linux --arch arm --variant=v6
 
-          # Create manifest with ALL tags in a single operation (much faster!)
-          echo "Creating multi-arch manifest with tags: ${TAGS[*]}"
-          docker buildx imagetools create "${TAG_ARGS[@]}" "${ARCH_IMAGES[@]}"
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/armv7-homeassistant:${tag_r}" \
+              --os linux --arch arm --variant=v7
 
-          # Sign each tag separately (signing requires individual tag names)
-          echo "Signing all tags..."
-          for tag in "${TAGS[@]}"; do
-            echo "Signing ${tag}"
-            cosign sign --yes "${tag}"
-          done
+            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
+              "${registry}/aarch64-homeassistant:${tag_r}" \
+              --os linux --arch arm64 --variant=v8
 
-          echo "All manifests created and signed successfully"
+            docker manifest push --purge "${registry}/home-assistant:${tag_l}"
+            cosign sign --yes "${registry}/home-assistant:${tag_l}"
+          }
+
+          function validate_image() {
+            local image=${1}
+            if ! cosign verify --certificate-oidc-issuer https://token.actions.githubusercontent.com --certificate-identity-regexp https://github.com/home-assistant/core/.* "${image}"; then
+              echo "Invalid signature!"
+              exit 1
+            fi
+          }
+
+          function push_dockerhub() {
+            local image=${1}
+            local tag=${2}
+
+            docker tag "ghcr.io/home-assistant/${image}:${tag}" "docker.io/homeassistant/${image}:${tag}"
+            docker push "docker.io/homeassistant/${image}:${tag}"
+            cosign sign --yes "docker.io/homeassistant/${image}:${tag}"
+          }
+
+          # Pull images from github container registry and verify signature
+          docker pull "ghcr.io/home-assistant/amd64-homeassistant:${{ needs.init.outputs.version }}"
+          docker pull "ghcr.io/home-assistant/i386-homeassistant:${{ needs.init.outputs.version }}"
+          docker pull "ghcr.io/home-assistant/armhf-homeassistant:${{ needs.init.outputs.version }}"
+          docker pull "ghcr.io/home-assistant/armv7-homeassistant:${{ needs.init.outputs.version }}"
+          docker pull "ghcr.io/home-assistant/aarch64-homeassistant:${{ needs.init.outputs.version }}"
+
+          validate_image "ghcr.io/home-assistant/amd64-homeassistant:${{ needs.init.outputs.version }}"
+          validate_image "ghcr.io/home-assistant/i386-homeassistant:${{ needs.init.outputs.version }}"
+          validate_image "ghcr.io/home-assistant/armhf-homeassistant:${{ needs.init.outputs.version }}"
+          validate_image "ghcr.io/home-assistant/armv7-homeassistant:${{ needs.init.outputs.version }}"
+          validate_image "ghcr.io/home-assistant/aarch64-homeassistant:${{ needs.init.outputs.version }}"
+
+          if [[ "${{ matrix.registry }}" ==  "docker.io/homeassistant" ]]; then
+            # Upload images to dockerhub
+            push_dockerhub "amd64-homeassistant" "${{ needs.init.outputs.version }}"
+            push_dockerhub "i386-homeassistant" "${{ needs.init.outputs.version }}"
+            push_dockerhub "armhf-homeassistant" "${{ needs.init.outputs.version }}"
+            push_dockerhub "armv7-homeassistant" "${{ needs.init.outputs.version }}"
+            push_dockerhub "aarch64-homeassistant" "${{ needs.init.outputs.version }}"
+          fi
+
+          # Create version tag
+          create_manifest "${{ needs.init.outputs.version }}" "${{ needs.init.outputs.version }}"
+
+          # Create general tags
+          if [[ "${{ needs.init.outputs.version }}" =~ d ]]; then
+            create_manifest "dev" "${{ needs.init.outputs.version }}"
+          elif [[ "${{ needs.init.outputs.version }}" =~ b ]]; then
+            create_manifest "beta" "${{ needs.init.outputs.version }}"
+            create_manifest "rc" "${{ needs.init.outputs.version }}"
+          else
+            create_manifest "stable" "${{ needs.init.outputs.version }}"
+            create_manifest "latest" "${{ needs.init.outputs.version }}"
+            create_manifest "beta" "${{ needs.init.outputs.version }}"
+            create_manifest "rc" "${{ needs.init.outputs.version }}"
+
+            # Create series version tag (e.g. 2021.6)
+            v="${{ needs.init.outputs.version }}"
+            create_manifest "${v%.*}" "${{ needs.init.outputs.version }}"
+          fi
 
   build_python:
     name: Build PyPi package
@@ -474,15 +454,15 @@ jobs:
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v5.0.0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
       - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@v5.0.0
         with:
           name: translations
 
@@ -500,7 +480,7 @@ jobs:
           python -m build
 
       - name: Upload package to PyPI
-        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
+        uses: pypa/gh-action-pypi-publish@v1.12.4
         with:
           skip-existing: true
 
@@ -519,10 +499,10 @@ jobs:
       HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@184bdaa0721073962dff0199f1fb9940f07167d1 # v3.5.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -551,7 +531,7 @@ jobs:
 
       - name: Generate artifact attestation
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@00014ed6ed5efc5b1ab7f7f34a39eb55d41aa4f8 # v3.1.0
+        uses: actions/attest-build-provenance@e8998f949152b193b063cb0ec769d69d929409be # v2.4.0
         with:
           subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
           subject-digest: ${{ steps.push.outputs.digest }}

.github/workflows/codeql.yml

@@ -21,14 +21,14 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v5.0.0
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/init@v3.29.9
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/analyze@v3.29.9
         with:
           category: "/language:python"

.github/workflows/detect-duplicate-issues.yml

@@ -16,7 +16,7 @@ jobs:
     steps:
       - name: Check if integration label was added and extract details
         id: extract
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        uses: actions/github-script@v7.0.1
         with:
           script: |
             // Debug: Log the event payload
@@ -113,7 +113,7 @@ jobs:
       - name: Fetch similar issues
         id: fetch_similar
         if: steps.extract.outputs.should_continue == 'true'
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        uses: actions/github-script@v7.0.1
         env:
           INTEGRATION_LABELS: ${{ steps.extract.outputs.integration_labels }}
           CURRENT_NUMBER: ${{ steps.extract.outputs.current_number }}
@@ -231,7 +231,7 @@ jobs:
       - name: Detect duplicates using AI
         id: ai_detection
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/ai-inference@a6101c89c6feaecc585efdd8d461f18bb7896f20 # v2.0.5
+        uses: actions/ai-inference@v2.0.0
         with:
           model: openai/gpt-4o
           system-prompt: |
@@ -280,7 +280,7 @@ jobs:
       - name: Post duplicate detection results
         id: post_results
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        uses: actions/github-script@v7.0.1
         env:
           AI_RESPONSE: ${{ steps.ai_detection.outputs.response }}
           SIMILAR_ISSUES: ${{ steps.fetch_similar.outputs.similar_issues }}

.github/workflows/detect-non-english-issues.yml

@@ -16,7 +16,7 @@ jobs:
     steps:
       - name: Check issue language
         id: detect_language
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        uses: actions/github-script@v7.0.1
         env:
           ISSUE_NUMBER: ${{ github.event.issue.number }}
           ISSUE_TITLE: ${{ github.event.issue.title }}
@@ -57,7 +57,7 @@ jobs:
       - name: Detect language using AI
         id: ai_language_detection
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/ai-inference@a6101c89c6feaecc585efdd8d461f18bb7896f20 # v2.0.5
+        uses: actions/ai-inference@v2.0.0
         with:
           model: openai/gpt-4o-mini
           system-prompt: |
@@ -90,7 +90,7 @@ jobs:
 
       - name: Process non-English issues
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        uses: actions/github-script@v7.0.1
         env:
           AI_RESPONSE: ${{ steps.ai_language_detection.outputs.response }}
           ISSUE_NUMBER: ${{ steps.detect_language.outputs.issue_number }}

.github/workflows/lock.yml

@@ -10,7 +10,7 @@ jobs:
     if: github.repository_owner == 'home-assistant'
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/lock-threads@7266a7ce5c1df01b1c6db85bf8cd86c737dadbe7 # v6.0.0
+      - uses: dessant/lock-threads@v5.0.1
         with:
           github-token: ${{ github.token }}
           issue-inactive-days: "30"

.github/workflows/matchers/check-executables-have-shebangs.json

@@ -4,7 +4,7 @@
       "owner": "check-executables-have-shebangs",
       "pattern": [
         {
-          "regexp": "^(.+):\\s(marked executable but has no \\(or invalid\\) shebang!.*)$",
+          "regexp": "^(.+):\\s(.+)$",
           "file": 1,
           "message": 2
         }

.github/workflows/restrict-task-creation.yml

@@ -12,7 +12,7 @@ jobs:
     if: github.event.issue.type.name == 'Task'
     steps:
       - name: Check if user is authorized
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        uses: actions/github-script@v7
         with:
           script: |
             const issueAuthor = context.payload.issue.user.login;

.github/workflows/stale.yml

@@ -17,7 +17,7 @@ jobs:
       # - No PRs marked as no-stale
       # - No issues (-1)
       - name: 60 days stale PRs policy
-        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
+        uses: actions/stale@v9.1.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: 60
@@ -57,7 +57,7 @@ jobs:
       # - No issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: 90 days stale issues
-        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
+        uses: actions/stale@v9.1.0
         with:
           repo-token: ${{ steps.token.outputs.token }}
           days-before-stale: 90
@@ -87,7 +87,7 @@ jobs:
       # - No Issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: Needs more information stale issues policy
-        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
+        uses: actions/stale@v9.1.0
         with:
           repo-token: ${{ steps.token.outputs.token }}
           only-labels: "needs-more-information"

.github/workflows/translations.yml

@@ -19,10 +19,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v5.0.0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 

.github/workflows/wheels.yml

@@ -28,14 +28,15 @@ jobs:
     name: Initialize wheels builder
     if: github.repository_owner == 'home-assistant'
     runs-on: ubuntu-latest
+    outputs:
+      architectures: ${{ steps.info.outputs.architectures }}
     steps:
-      - &checkout
-        name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - name: Checkout the repository
+        uses: actions/checkout@v5.0.0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.6.0
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           check-latest: true
@@ -48,6 +49,10 @@ jobs:
           pip install "$(grep '^uv' < requirements.txt)"
           uv pip install -r requirements.txt
 
+      - name: Get information
+        id: info
+        uses: home-assistant/actions/helpers/info@master
+
       - name: Create requirements_diff file
         run: |
           if [[ ${{ github.event_name }} =~ (schedule|workflow_dispatch) ]]; then
@@ -71,18 +76,37 @@ jobs:
 
             # Use C-Extension for SQLAlchemy
             echo "REQUIRE_SQLALCHEMY_CEXT=1"
+
+            # Add additional pip wheel build constraints
+            echo "PIP_CONSTRAINT=build_constraints.txt"
           ) > .env_file
 
+      - name: Write pip wheel build constraints
+        run: |
+          (
+            # ninja 1.11.1.2 + 1.11.1.3 seem to be broken on at least armhf
+            # this caused the numpy builds to fail
+            # https://github.com/scikit-build/ninja-python-distributions/issues/274
+            echo "ninja==1.11.1.1"
+          ) > build_constraints.txt
+
       - name: Upload env_file
-        uses: &actions-upload-artifact actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@v4.6.2
         with:
           name: env_file
           path: ./.env_file
           include-hidden-files: true
           overwrite: true
 
+      - name: Upload build_constraints
+        uses: actions/upload-artifact@v4.6.2
+        with:
+          name: build_constraints
+          path: ./build_constraints.txt
+          overwrite: true
+
       - name: Upload requirements_diff
-        uses: *actions-upload-artifact
+        uses: actions/upload-artifact@v4.6.2
         with:
           name: requirements_diff
           path: ./requirements_diff.txt
@@ -94,7 +118,7 @@ jobs:
           python -m script.gen_requirements_all ci
 
       - name: Upload requirements_all_wheels
-        uses: *actions-upload-artifact
+        uses: actions/upload-artifact@v4.6.2
         with:
           name: requirements_all_wheels
           path: ./requirements_all_wheels_*.txt
@@ -103,29 +127,28 @@ jobs:
     name: Build Core wheels ${{ matrix.abi }} for ${{ matrix.arch }} (musllinux_1_2)
     if: github.repository_owner == 'home-assistant'
     needs: init
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
-      matrix: &matrix-build
-        abi: ["cp313", "cp314"]
-        arch: ["amd64", "aarch64"]
-        include:
-          - arch: amd64
-            os: ubuntu-latest
-          - arch: aarch64
-            os: ubuntu-24.04-arm
+      matrix:
+        abi: ["cp313"]
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
     steps:
-      - *checkout
+      - name: Checkout the repository
+        uses: actions/checkout@v5.0.0
 
-      - &download-env-file
-        name: Download env_file
-        uses: &actions-download-artifact actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+      - name: Download env_file
+        uses: actions/download-artifact@v5.0.0
         with:
           name: env_file
 
-      - &download-requirements-diff
-        name: Download requirements_diff
-        uses: *actions-download-artifact
+      - name: Download build_constraints
+        uses: actions/download-artifact@v5.0.0
+        with:
+          name: build_constraints
+
+      - name: Download requirements_diff
+        uses: actions/download-artifact@v5.0.0
         with:
           name: requirements_diff
 
@@ -136,7 +159,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: &home-assistant-wheels home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: home-assistant/wheels@2025.07.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
@@ -153,24 +176,42 @@ jobs:
     name: Build wheels ${{ matrix.abi }} for ${{ matrix.arch }}
     if: github.repository_owner == 'home-assistant'
     needs: init
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
     strategy:
       fail-fast: false
-      matrix: *matrix-build
+      matrix:
+        abi: ["cp313"]
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
     steps:
-      - *checkout
+      - name: Checkout the repository
+        uses: actions/checkout@v5.0.0
 
-      - *download-env-file
+      - name: Download env_file
+        uses: actions/download-artifact@v5.0.0
+        with:
+          name: env_file
 
-      - *download-requirements-diff
+      - name: Download build_constraints
+        uses: actions/download-artifact@v5.0.0
+        with:
+          name: build_constraints
+
+      - name: Download requirements_diff
+        uses: actions/download-artifact@v5.0.0
+        with:
+          name: requirements_diff
 
       - name: Download requirements_all_wheels
-        uses: *actions-download-artifact
+        uses: actions/download-artifact@v5.0.0
         with:
           name: requirements_all_wheels
 
       - name: Adjust build env
         run: |
+          if [ "${{ matrix.arch }}" = "i386" ]; then
+            echo "NPY_DISABLE_SVML=1" >> .env_file
+          fi
+
           # Do not pin numpy in wheels building
           sed -i "/numpy/d" homeassistant/package_constraints.txt
           # Don't build wheels for uv as uv requires a greater version of rust as currently available on alpine
@@ -178,14 +219,14 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: *home-assistant-wheels
+        uses: home-assistant/wheels@2025.07.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
           arch: ${{ matrix.arch }}
           wheels-key: ${{ secrets.WHEELS_KEY }}
           env-file: true
-          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-ng-dev"
+          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-ng-dev"
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"

.gitignore

@@ -79,6 +79,7 @@ junit.xml
 .project
 .pydevproject
 
+.python-version
 .tool-versions
 
 # emacs auto backups
@@ -92,7 +93,6 @@ pip-selfcheck.json
 venv
 .venv
 Pipfile*
-uv.lock
 share/*
 /Scripts/
 
@@ -112,7 +112,6 @@ virtualization/vagrant/config
 !.vscode/cSpell.json
 !.vscode/extensions.json
 !.vscode/tasks.json
-!.vscode/settings.default.jsonc
 .env
 
 # Windows Explorer
@@ -141,6 +140,5 @@ tmp_cache
 pytest_buckets.txt
 
 # AI tooling
-.claude/settings.local.json
-.serena/
+.claude
 

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.13
+    rev: v0.12.1
     hooks:
       - id: ruff-check
         args:
@@ -33,20 +33,17 @@ repos:
     rev: v1.37.1
     hooks:
       - id: yamllint
-  - repo: https://github.com/rbubley/mirrors-prettier
-    rev: v3.6.2
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.0.3
     hooks:
       - id: prettier
-        additional_dependencies:
-          - prettier@3.6.2
-          - prettier-plugin-sort-json@4.2.0
   - repo: https://github.com/cdce8p/python-typing-update
     rev: v0.6.0
     hooks:
       # Run `python-typing-update` hook manually from time to time
       # to update python typing syntax.
       # Will require manual work, before submitting changes!
-      # prek run --hook-stage manual python-typing-update --all-files
+      # pre-commit run --hook-stage manual python-typing-update --all-files
       - id: python-typing-update
         stages: [manual]
         args:
@@ -87,14 +84,14 @@ repos:
         pass_filenames: false
         language: script
         types: [text]
-        files: ^(homeassistant/.+/(icons|manifest|strings)\.json|homeassistant/.+/(conditions|quality_scale|services|triggers)\.yaml|homeassistant/brands/.*\.json|script/hassfest/(?!metadata|mypy_config).+\.py|requirements.+\.txt)$
+        files: ^(homeassistant/.+/(icons|manifest|strings)\.json|homeassistant/.+/(quality_scale)\.yaml|homeassistant/brands/.*\.json|homeassistant/.+/services\.yaml|script/hassfest/(?!metadata|mypy_config).+\.py|requirements.+\.txt)$
       - id: hassfest-metadata
         name: hassfest-metadata
         entry: script/run-in-env.sh python3 -m script.hassfest -p metadata,docker
         pass_filenames: false
         language: script
         types: [text]
-        files: ^(script/hassfest/(metadata|docker)\.py|homeassistant/const\.py$|pyproject\.toml)$
+        files: ^(script/hassfest/metadata\.py|homeassistant/const\.py$|pyproject\.toml|homeassistant/components/go2rtc/const\.py)$
       - id: hassfest-mypy-config
         name: hassfest-mypy-config
         entry: script/run-in-env.sh python3 -m script.hassfest -p mypy_config

.prettierrc.js

@@ -1,24 +0,0 @@
-/** @type {import("prettier").Config} */
-module.exports = {
-  overrides: [
-    {
-      files: "./homeassistant/**/*.json",
-      options: {
-        plugins: [require.resolve("prettier-plugin-sort-json")],
-        jsonRecursiveSort: true,
-        jsonSortOrder: JSON.stringify({ [/.*/]: "numeric" }),
-      },
-    },
-    {
-      files: ["manifest.json", "./**/brands/*.json"],
-      options: {
-        // domain and name should stay at the top
-        jsonSortOrder: JSON.stringify({
-          domain: null,
-          name: null,
-          [/.*/]: "numeric",
-        }),
-      },
-    },
-  ],
-};

.python-version

@@ -1 +0,0 @@
-3.13

.strict-typing

@@ -107,7 +107,6 @@ homeassistant.components.automation.*
 homeassistant.components.awair.*
 homeassistant.components.axis.*
 homeassistant.components.azure_storage.*
-homeassistant.components.backblaze_b2.*
 homeassistant.components.backup.*
 homeassistant.components.baf.*
 homeassistant.components.bang_olufsen.*
@@ -120,6 +119,7 @@ homeassistant.components.blueprint.*
 homeassistant.components.bluesound.*
 homeassistant.components.bluetooth.*
 homeassistant.components.bluetooth_adapters.*
+homeassistant.components.bluetooth_tracker.*
 homeassistant.components.bmw_connected_drive.*
 homeassistant.components.bond.*
 homeassistant.components.bosch_alarm.*
@@ -142,7 +142,6 @@ homeassistant.components.cloud.*
 homeassistant.components.co2signal.*
 homeassistant.components.comelit.*
 homeassistant.components.command_line.*
-homeassistant.components.compit.*
 homeassistant.components.config.*
 homeassistant.components.configurator.*
 homeassistant.components.cookidoo.*
@@ -170,7 +169,6 @@ homeassistant.components.dnsip.*
 homeassistant.components.doorbird.*
 homeassistant.components.dormakaba_dkey.*
 homeassistant.components.downloader.*
-homeassistant.components.droplet.*
 homeassistant.components.dsmr.*
 homeassistant.components.duckdns.*
 homeassistant.components.dunehd.*
@@ -182,12 +180,12 @@ homeassistant.components.efergy.*
 homeassistant.components.eheimdigital.*
 homeassistant.components.electrasmart.*
 homeassistant.components.electric_kiwi.*
+homeassistant.components.elevenlabs.*
 homeassistant.components.elgato.*
 homeassistant.components.elkm1.*
 homeassistant.components.emulated_hue.*
 homeassistant.components.energenie_power_sockets.*
 homeassistant.components.energy.*
-homeassistant.components.energyid.*
 homeassistant.components.energyzero.*
 homeassistant.components.enigma2.*
 homeassistant.components.enphase_envoy.*
@@ -203,7 +201,6 @@ homeassistant.components.feedreader.*
 homeassistant.components.file_upload.*
 homeassistant.components.filesize.*
 homeassistant.components.filter.*
-homeassistant.components.firefly_iii.*
 homeassistant.components.fitbit.*
 homeassistant.components.flexit_bacnet.*
 homeassistant.components.flux_led.*
@@ -221,7 +218,6 @@ homeassistant.components.generic_thermostat.*
 homeassistant.components.geo_location.*
 homeassistant.components.geocaching.*
 homeassistant.components.gios.*
-homeassistant.components.github.*
 homeassistant.components.glances.*
 homeassistant.components.go2rtc.*
 homeassistant.components.goalzero.*
@@ -231,7 +227,6 @@ homeassistant.components.google_cloud.*
 homeassistant.components.google_drive.*
 homeassistant.components.google_photos.*
 homeassistant.components.google_sheets.*
-homeassistant.components.google_weather.*
 homeassistant.components.govee_ble.*
 homeassistant.components.gpsd.*
 homeassistant.components.greeneye_monitor.*
@@ -280,7 +275,6 @@ homeassistant.components.imap.*
 homeassistant.components.imgw_pib.*
 homeassistant.components.immich.*
 homeassistant.components.incomfort.*
-homeassistant.components.inels.*
 homeassistant.components.input_button.*
 homeassistant.components.input_select.*
 homeassistant.components.input_text.*
@@ -313,7 +307,6 @@ homeassistant.components.ld2410_ble.*
 homeassistant.components.led_ble.*
 homeassistant.components.lektrico.*
 homeassistant.components.letpot.*
-homeassistant.components.libre_hardware_monitor.*
 homeassistant.components.lidarr.*
 homeassistant.components.lifx.*
 homeassistant.components.light.*
@@ -329,7 +322,6 @@ homeassistant.components.london_underground.*
 homeassistant.components.lookin.*
 homeassistant.components.lovelace.*
 homeassistant.components.luftdaten.*
-homeassistant.components.lunatone.*
 homeassistant.components.madvr.*
 homeassistant.components.manual.*
 homeassistant.components.mastodon.*
@@ -390,13 +382,13 @@ homeassistant.components.openai_conversation.*
 homeassistant.components.openexchangerates.*
 homeassistant.components.opensky.*
 homeassistant.components.openuv.*
-homeassistant.components.opnsense.*
 homeassistant.components.opower.*
 homeassistant.components.oralb.*
 homeassistant.components.otbr.*
 homeassistant.components.overkiz.*
 homeassistant.components.overseerr.*
 homeassistant.components.p1_monitor.*
+homeassistant.components.pandora.*
 homeassistant.components.panel_custom.*
 homeassistant.components.paperless_ngx.*
 homeassistant.components.peblar.*
@@ -407,8 +399,6 @@ homeassistant.components.person.*
 homeassistant.components.pi_hole.*
 homeassistant.components.ping.*
 homeassistant.components.plugwise.*
-homeassistant.components.pooldose.*
-homeassistant.components.portainer.*
 homeassistant.components.powerfox.*
 homeassistant.components.powerwall.*
 homeassistant.components.private_ble_device.*
@@ -448,14 +438,12 @@ homeassistant.components.rituals_perfume_genie.*
 homeassistant.components.roborock.*
 homeassistant.components.roku.*
 homeassistant.components.romy.*
-homeassistant.components.route_b_smart_meter.*
 homeassistant.components.rpi_power.*
 homeassistant.components.rss_feed_template.*
 homeassistant.components.russound_rio.*
 homeassistant.components.ruuvi_gateway.*
 homeassistant.components.ruuvitag_ble.*
 homeassistant.components.samsungtv.*
-homeassistant.components.saunum.*
 homeassistant.components.scene.*
 homeassistant.components.schedule.*
 homeassistant.components.schlage.*
@@ -470,7 +458,6 @@ homeassistant.components.sensorpush_cloud.*
 homeassistant.components.sensoterra.*
 homeassistant.components.senz.*
 homeassistant.components.sfr_box.*
-homeassistant.components.sftp_storage.*
 homeassistant.components.shell_command.*
 homeassistant.components.shelly.*
 homeassistant.components.shopping_list.*
@@ -481,7 +468,6 @@ homeassistant.components.skybell.*
 homeassistant.components.slack.*
 homeassistant.components.sleep_as_android.*
 homeassistant.components.sleepiq.*
-homeassistant.components.sma.*
 homeassistant.components.smhi.*
 homeassistant.components.smlight.*
 homeassistant.components.smtp.*
@@ -560,7 +546,6 @@ homeassistant.components.vacuum.*
 homeassistant.components.vallox.*
 homeassistant.components.valve.*
 homeassistant.components.velbus.*
-homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*
 homeassistant.components.volvo.*
@@ -569,7 +554,6 @@ homeassistant.components.wake_word.*
 homeassistant.components.wallbox.*
 homeassistant.components.waqi.*
 homeassistant.components.water_heater.*
-homeassistant.components.watts.*
 homeassistant.components.watttime.*
 homeassistant.components.weather.*
 homeassistant.components.webhook.*
@@ -582,7 +566,6 @@ homeassistant.components.wiz.*
 homeassistant.components.wled.*
 homeassistant.components.workday.*
 homeassistant.components.worldclock.*
-homeassistant.components.xbox.*
 homeassistant.components.xiaomi_ble.*
 homeassistant.components.yale_smart_alarm.*
 homeassistant.components.yalexs_ble.*

.vscode/settings.default.json

@@ -0,0 +1,19 @@
+{
+  // Please keep this file (mostly!) in sync with settings in home-assistant/.devcontainer/devcontainer.json
+  // Added --no-cov to work around TypeError: message must be set
+  // https://github.com/microsoft/vscode-python/issues/14067
+  "python.testing.pytestArgs": ["--no-cov"],
+  // https://code.visualstudio.com/docs/python/testing#_pytest-configuration-settings
+  "python.testing.pytestEnabled": false,
+  // https://code.visualstudio.com/docs/python/linting#_general-settings
+  "pylint.importStrategy": "fromEnvironment",
+  "json.schemas": [
+        {
+            "fileMatch": [
+                "homeassistant/components/*/manifest.json"
+            ],
+            // This value differs between working with devcontainer and locally, therefor this value should NOT be in sync!
+            "url": "./script/json_schemas/manifest_schema.json"
+        }
+    ]
+}

.vscode/settings.default.jsonc

@@ -1,25 +0,0 @@
-{
-  // Please keep this file (mostly!) in sync with settings in home-assistant/.devcontainer/devcontainer.json
-  // Added --no-cov to work around TypeError: message must be set
-  // https://github.com/microsoft/vscode-python/issues/14067
-  "python.testing.pytestArgs": ["--no-cov"],
-  // https://code.visualstudio.com/docs/python/testing#_pytest-configuration-settings
-  "python.testing.pytestEnabled": false,
-  // https://code.visualstudio.com/docs/python/linting#_general-settings
-  "pylint.importStrategy": "fromEnvironment",
-  // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
-  "python.analysis.typeCheckingMode": "off",
-  "[python]": {
-    "editor.defaultFormatter": "charliermarsh.ruff",
-  },
-  "[json][jsonc][yaml]": {
-    "editor.defaultFormatter": "esbenp.prettier-vscode",
-  },
-  "json.schemas": [
-    {
-      "fileMatch": ["homeassistant/components/*/manifest.json"],
-      // This value differs between working with devcontainer and locally, therefore this value should NOT be in sync!
-      "url": "./script/json_schemas/manifest_schema.json",
-    },
-  ],
-}

.vscode/tasks.json

@@ -45,7 +45,7 @@
     {
       "label": "Ruff",
       "type": "shell",
-      "command": "prek run ruff-check --all-files",
+      "command": "pre-commit run ruff-check --all-files",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -57,9 +57,9 @@
       "problemMatcher": []
     },
     {
-      "label": "Prek",
+      "label": "Pre-commit",
       "type": "shell",
-      "command": "prek run --show-diff-on-failure",
+      "command": "pre-commit run --show-diff-on-failure",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -120,7 +120,7 @@
     {
       "label": "Generate Requirements",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m script.gen_requirements_all",
+      "command": "./script/gen_requirements_all.py",
       "group": {
         "kind": "build",
         "isDefault": true

AGENTS.md

@@ -1 +0,0 @@
-.github/copilot-instructions.md

CODEOWNERS

@@ -46,8 +46,6 @@ build.json @home-assistant/supervisor
 /tests/components/accuweather/ @bieniu
 /homeassistant/components/acmeda/ @atmurray
 /tests/components/acmeda/ @atmurray
-/homeassistant/components/actron_air/ @kclif9 @JagadishDhanamjayam
-/tests/components/actron_air/ @kclif9 @JagadishDhanamjayam
 /homeassistant/components/adax/ @danielhiversen @lazytarget
 /tests/components/adax/ @danielhiversen @lazytarget
 /homeassistant/components/adguard/ @frenck
@@ -69,12 +67,8 @@ build.json @home-assistant/supervisor
 /tests/components/airly/ @bieniu
 /homeassistant/components/airnow/ @asymworks
 /tests/components/airnow/ @asymworks
-/homeassistant/components/airobot/ @mettolen
-/tests/components/airobot/ @mettolen
 /homeassistant/components/airos/ @CoMPaTech
 /tests/components/airos/ @CoMPaTech
-/homeassistant/components/airpatrol/ @antondalgren
-/tests/components/airpatrol/ @antondalgren
 /homeassistant/components/airq/ @Sibgatulin @dl2080
 /tests/components/airq/ @Sibgatulin @dl2080
 /homeassistant/components/airthings/ @danielhiversen @LaStrada
@@ -93,8 +87,6 @@ build.json @home-assistant/supervisor
 /tests/components/airzone/ @Noltari
 /homeassistant/components/airzone_cloud/ @Noltari
 /tests/components/airzone_cloud/ @Noltari
-/homeassistant/components/aladdin_connect/ @swcloudgenie
-/tests/components/aladdin_connect/ @swcloudgenie
 /homeassistant/components/alarm_control_panel/ @home-assistant/core
 /tests/components/alarm_control_panel/ @home-assistant/core
 /homeassistant/components/alert/ @home-assistant/core @frenck
@@ -113,8 +105,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/ambient_station/ @bachya
 /tests/components/ambient_station/ @bachya
 /homeassistant/components/amcrest/ @flacjacket
-/homeassistant/components/analytics/ @home-assistant/core
-/tests/components/analytics/ @home-assistant/core
+/homeassistant/components/analytics/ @home-assistant/core @ludeeus
+/tests/components/analytics/ @home-assistant/core @ludeeus
 /homeassistant/components/analytics_insights/ @joostlek
 /tests/components/analytics_insights/ @joostlek
 /homeassistant/components/android_ip_webcam/ @engrbm87
@@ -123,8 +115,6 @@ build.json @home-assistant/supervisor
 /tests/components/androidtv/ @JeffLIrion @ollo69
 /homeassistant/components/androidtv_remote/ @tronikos @Drafteed
 /tests/components/androidtv_remote/ @tronikos @Drafteed
-/homeassistant/components/anglian_water/ @pantherale0
-/tests/components/anglian_water/ @pantherale0
 /homeassistant/components/anova/ @Lash-L
 /tests/components/anova/ @Lash-L
 /homeassistant/components/anthemav/ @hyralex
@@ -162,10 +152,10 @@ build.json @home-assistant/supervisor
 /tests/components/arve/ @ikalnyi
 /homeassistant/components/aseko_pool_live/ @milanmeu
 /tests/components/aseko_pool_live/ @milanmeu
-/homeassistant/components/assist_pipeline/ @synesthesiam @arturpragacz
-/tests/components/assist_pipeline/ @synesthesiam @arturpragacz
-/homeassistant/components/assist_satellite/ @home-assistant/core @synesthesiam @arturpragacz
-/tests/components/assist_satellite/ @home-assistant/core @synesthesiam @arturpragacz
+/homeassistant/components/assist_pipeline/ @balloob @synesthesiam
+/tests/components/assist_pipeline/ @balloob @synesthesiam
+/homeassistant/components/assist_satellite/ @home-assistant/core @synesthesiam
+/tests/components/assist_satellite/ @home-assistant/core @synesthesiam
 /homeassistant/components/asuswrt/ @kennedyshead @ollo69 @Vaskivskyi
 /tests/components/asuswrt/ @kennedyshead @ollo69 @Vaskivskyi
 /homeassistant/components/atag/ @MatsNL
@@ -187,8 +177,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/automation/ @home-assistant/core
 /tests/components/automation/ @home-assistant/core
 /homeassistant/components/avea/ @pattyland
-/homeassistant/components/awair/ @ahayworth @ricohageman
-/tests/components/awair/ @ahayworth @ricohageman
+/homeassistant/components/awair/ @ahayworth @danielsjf
+/tests/components/awair/ @ahayworth @danielsjf
 /homeassistant/components/aws_s3/ @tomasbedrich
 /tests/components/aws_s3/ @tomasbedrich
 /homeassistant/components/axis/ @Kane610
@@ -202,8 +192,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/azure_service_bus/ @hfurubotten
 /homeassistant/components/azure_storage/ @zweckj
 /tests/components/azure_storage/ @zweckj
-/homeassistant/components/backblaze_b2/ @hugo-vrijswijk @ElCruncharino
-/tests/components/backblaze_b2/ @hugo-vrijswijk @ElCruncharino
 /homeassistant/components/backup/ @home-assistant/core
 /tests/components/backup/ @home-assistant/core
 /homeassistant/components/baf/ @bdraco @jfroy
@@ -220,8 +208,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/bizkaibus/ @UgaitzEtxebarria
 /homeassistant/components/blebox/ @bbx-a @swistakm
 /tests/components/blebox/ @bbx-a @swistakm
-/homeassistant/components/blink/ @fronzbot
-/tests/components/blink/ @fronzbot
+/homeassistant/components/blink/ @fronzbot @mkmer
+/tests/components/blink/ @fronzbot @mkmer
 /homeassistant/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
 /tests/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
 /homeassistant/components/bluemaestro/ @bdraco
@@ -302,16 +290,14 @@ build.json @home-assistant/supervisor
 /tests/components/command_line/ @gjohansson-ST
 /homeassistant/components/compensation/ @Petro31
 /tests/components/compensation/ @Petro31
-/homeassistant/components/compit/ @Przemko92
-/tests/components/compit/ @Przemko92
 /homeassistant/components/config/ @home-assistant/core
 /tests/components/config/ @home-assistant/core
 /homeassistant/components/configurator/ @home-assistant/core
 /tests/components/configurator/ @home-assistant/core
-/homeassistant/components/control4/ @lawtancool @davidrecordon
-/tests/components/control4/ @lawtancool @davidrecordon
-/homeassistant/components/conversation/ @home-assistant/core @synesthesiam @arturpragacz
-/tests/components/conversation/ @home-assistant/core @synesthesiam @arturpragacz
+/homeassistant/components/control4/ @lawtancool
+/tests/components/control4/ @lawtancool
+/homeassistant/components/conversation/ @home-assistant/core @synesthesiam
+/tests/components/conversation/ @home-assistant/core @synesthesiam
 /homeassistant/components/cookidoo/ @miaucl
 /tests/components/cookidoo/ @miaucl
 /homeassistant/components/coolmaster/ @OnFreund
@@ -324,8 +310,8 @@ build.json @home-assistant/supervisor
 /tests/components/cpuspeed/ @fabaff
 /homeassistant/components/crownstone/ @Crownstone @RicArch97
 /tests/components/crownstone/ @Crownstone @RicArch97
-/homeassistant/components/cync/ @Kinachi249
-/tests/components/cync/ @Kinachi249
+/homeassistant/components/cups/ @fabaff
+/tests/components/cups/ @fabaff
 /homeassistant/components/daikin/ @fredrike
 /tests/components/daikin/ @fredrike
 /homeassistant/components/date/ @home-assistant/core
@@ -389,14 +375,10 @@ build.json @home-assistant/supervisor
 /tests/components/dremel_3d_printer/ @tkdrob
 /homeassistant/components/drop_connect/ @ChandlerSystems @pfrazer
 /tests/components/drop_connect/ @ChandlerSystems @pfrazer
-/homeassistant/components/droplet/ @sarahseidman
-/tests/components/droplet/ @sarahseidman
 /homeassistant/components/dsmr/ @Robbie1221
 /tests/components/dsmr/ @Robbie1221
 /homeassistant/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
 /tests/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
-/homeassistant/components/duckdns/ @tr4nt0r
-/tests/components/duckdns/ @tr4nt0r
 /homeassistant/components/duke_energy/ @hunterjm
 /tests/components/duke_energy/ @hunterjm
 /homeassistant/components/duotecno/ @cereal2nd
@@ -420,12 +402,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/efergy/ @tkdrob
 /tests/components/efergy/ @tkdrob
 /homeassistant/components/egardia/ @jeroenterheerdt
-/homeassistant/components/egauge/ @neggert
-/tests/components/egauge/ @neggert
 /homeassistant/components/eheimdigital/ @autinerd
 /tests/components/eheimdigital/ @autinerd
-/homeassistant/components/ekeybionyx/ @richardpolzer
-/tests/components/ekeybionyx/ @richardpolzer
 /homeassistant/components/electrasmart/ @jafar-atili
 /tests/components/electrasmart/ @jafar-atili
 /homeassistant/components/electric_kiwi/ @mikey0000
@@ -444,8 +422,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/emby/ @mezz64
 /homeassistant/components/emoncms/ @borpin @alexandrecuer
 /tests/components/emoncms/ @borpin @alexandrecuer
-/homeassistant/components/emoncms_history/ @alexandrecuer
-/tests/components/emoncms_history/ @alexandrecuer
 /homeassistant/components/emonitor/ @bdraco
 /tests/components/emonitor/ @bdraco
 /homeassistant/components/emulated_hue/ @bdraco @Tho85
@@ -456,15 +432,15 @@ build.json @home-assistant/supervisor
 /tests/components/energenie_power_sockets/ @gnumpi
 /homeassistant/components/energy/ @home-assistant/core
 /tests/components/energy/ @home-assistant/core
-/homeassistant/components/energyid/ @JrtPec @Molier
-/tests/components/energyid/ @JrtPec @Molier
 /homeassistant/components/energyzero/ @klaasnicolaas
 /tests/components/energyzero/ @klaasnicolaas
 /homeassistant/components/enigma2/ @autinerd
 /tests/components/enigma2/ @autinerd
+/homeassistant/components/enocean/ @bdurrer
+/tests/components/enocean/ @bdurrer
 /homeassistant/components/enphase_envoy/ @bdraco @cgarwood @catsmanac
 /tests/components/enphase_envoy/ @bdraco @cgarwood @catsmanac
-/homeassistant/components/entur_public_transport/ @hfurubotten @SanderBlom
+/homeassistant/components/entur_public_transport/ @hfurubotten
 /homeassistant/components/environment_canada/ @gwww @michaeldavie
 /tests/components/environment_canada/ @gwww @michaeldavie
 /homeassistant/components/ephember/ @ttroy50 @roberty99
@@ -480,12 +456,12 @@ build.json @home-assistant/supervisor
 /tests/components/escea/ @lazdavila
 /homeassistant/components/esphome/ @jesserockz @kbx81 @bdraco
 /tests/components/esphome/ @jesserockz @kbx81 @bdraco
-/homeassistant/components/essent/ @jaapp
-/tests/components/essent/ @jaapp
 /homeassistant/components/eufylife_ble/ @bdr99
 /tests/components/eufylife_ble/ @bdr99
 /homeassistant/components/event/ @home-assistant/core
 /tests/components/event/ @home-assistant/core
+/homeassistant/components/evil_genius_labs/ @balloob
+/tests/components/evil_genius_labs/ @balloob
 /homeassistant/components/evohome/ @zxdavb
 /tests/components/evohome/ @zxdavb
 /homeassistant/components/ezviz/ @RenierM26
@@ -508,16 +484,10 @@ build.json @home-assistant/supervisor
 /tests/components/filesize/ @gjohansson-ST
 /homeassistant/components/filter/ @dgomes
 /tests/components/filter/ @dgomes
-/homeassistant/components/fing/ @Lorenzo-Gasparini
-/tests/components/fing/ @Lorenzo-Gasparini
-/homeassistant/components/firefly_iii/ @erwindouna
-/tests/components/firefly_iii/ @erwindouna
 /homeassistant/components/fireservicerota/ @cyberjunky
 /tests/components/fireservicerota/ @cyberjunky
 /homeassistant/components/firmata/ @DaAwesomeP
 /tests/components/firmata/ @DaAwesomeP
-/homeassistant/components/fish_audio/ @noambav
-/tests/components/fish_audio/ @noambav
 /homeassistant/components/fitbit/ @allenporter
 /tests/components/fitbit/ @allenporter
 /homeassistant/components/fivem/ @Sander0542
@@ -526,14 +496,14 @@ build.json @home-assistant/supervisor
 /tests/components/fjaraskupan/ @elupus
 /homeassistant/components/flexit_bacnet/ @lellky @piotrbulinski
 /tests/components/flexit_bacnet/ @lellky @piotrbulinski
+/homeassistant/components/flick_electric/ @ZephireNZ
+/tests/components/flick_electric/ @ZephireNZ
 /homeassistant/components/flipr/ @cnico
 /tests/components/flipr/ @cnico
 /homeassistant/components/flo/ @dmulcahey
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
-/homeassistant/components/fluss/ @fluss
-/tests/components/fluss/ @fluss
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck
@@ -541,14 +511,12 @@ build.json @home-assistant/supervisor
 /homeassistant/components/forked_daapd/ @uvjustin
 /tests/components/forked_daapd/ @uvjustin
 /homeassistant/components/fortios/ @kimfrellsen
-/homeassistant/components/foscam/ @Foscam-wangzhengyu
-/tests/components/foscam/ @Foscam-wangzhengyu
+/homeassistant/components/foscam/ @krmarien
+/tests/components/foscam/ @krmarien
 /homeassistant/components/freebox/ @hacf-fr @Quentame
 /tests/components/freebox/ @hacf-fr @Quentame
 /homeassistant/components/freedompro/ @stefano055415
 /tests/components/freedompro/ @stefano055415
-/homeassistant/components/fressnapf_tracker/ @eifinger
-/tests/components/fressnapf_tracker/ @eifinger
 /homeassistant/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /tests/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /homeassistant/components/fritzbox/ @mib1185 @flabbamann
@@ -579,8 +547,6 @@ build.json @home-assistant/supervisor
 /tests/components/generic_hygrostat/ @Shulyaka
 /homeassistant/components/geniushub/ @manzanotti
 /tests/components/geniushub/ @manzanotti
-/homeassistant/components/gentex_homelink/ @niaexa @ryanjones-gentex
-/tests/components/gentex_homelink/ @niaexa @ryanjones-gentex
 /homeassistant/components/geo_json_events/ @exxamalte
 /tests/components/geo_json_events/ @exxamalte
 /homeassistant/components/geo_location/ @home-assistant/core
@@ -609,8 +575,6 @@ build.json @home-assistant/supervisor
 /tests/components/goodwe/ @mletenay @starkillerOG
 /homeassistant/components/google/ @allenporter
 /tests/components/google/ @allenporter
-/homeassistant/components/google_air_quality/ @Thomas55555
-/tests/components/google_air_quality/ @Thomas55555
 /homeassistant/components/google_assistant/ @home-assistant/cloud
 /tests/components/google_assistant/ @home-assistant/cloud
 /homeassistant/components/google_assistant_sdk/ @tronikos
@@ -631,8 +595,6 @@ build.json @home-assistant/supervisor
 /tests/components/google_tasks/ @allenporter
 /homeassistant/components/google_travel_time/ @eifinger
 /tests/components/google_travel_time/ @eifinger
-/homeassistant/components/google_weather/ @tronikos
-/tests/components/google_weather/ @tronikos
 /homeassistant/components/govee_ble/ @bdraco
 /tests/components/govee_ble/ @bdraco
 /homeassistant/components/govee_light_local/ @Galorhallen
@@ -645,14 +607,10 @@ build.json @home-assistant/supervisor
 /tests/components/greeneye_monitor/ @jkeljo
 /homeassistant/components/group/ @home-assistant/core
 /tests/components/group/ @home-assistant/core
-/homeassistant/components/growatt_server/ @johanzander
-/tests/components/growatt_server/ @johanzander
 /homeassistant/components/guardian/ @bachya
 /tests/components/guardian/ @bachya
 /homeassistant/components/habitica/ @tr4nt0r
 /tests/components/habitica/ @tr4nt0r
-/homeassistant/components/hanna/ @bestycame
-/tests/components/hanna/ @bestycame
 /homeassistant/components/hardkernel/ @home-assistant/core
 /tests/components/hardkernel/ @home-assistant/core
 /homeassistant/components/hardware/ @home-assistant/core
@@ -661,8 +619,6 @@ build.json @home-assistant/supervisor
 /tests/components/harmony/ @ehendrix23 @bdraco @mkeesey @Aohzan
 /homeassistant/components/hassio/ @home-assistant/supervisor
 /tests/components/hassio/ @home-assistant/supervisor
-/homeassistant/components/hdfury/ @glenndehaan
-/tests/components/hdfury/ @glenndehaan
 /homeassistant/components/hdmi_cec/ @inytar
 /tests/components/hdmi_cec/ @inytar
 /homeassistant/components/heatmiser/ @andylockran
@@ -670,8 +626,7 @@ build.json @home-assistant/supervisor
 /tests/components/heos/ @andrewsayre
 /homeassistant/components/here_travel_time/ @eifinger
 /tests/components/here_travel_time/ @eifinger
-/homeassistant/components/hikvision/ @mezz64 @ptarjan
-/tests/components/hikvision/ @mezz64 @ptarjan
+/homeassistant/components/hikvision/ @mezz64
 /homeassistant/components/hikvisioncam/ @fbradyirl
 /homeassistant/components/hisense_aehw4a1/ @bannhead
 /tests/components/hisense_aehw4a1/ @bannhead
@@ -691,8 +646,6 @@ build.json @home-assistant/supervisor
 /tests/components/homeassistant/ @home-assistant/core
 /homeassistant/components/homeassistant_alerts/ @home-assistant/core
 /tests/components/homeassistant_alerts/ @home-assistant/core
-/homeassistant/components/homeassistant_connect_zbt2/ @home-assistant/core
-/tests/components/homeassistant_connect_zbt2/ @home-assistant/core
 /homeassistant/components/homeassistant_green/ @home-assistant/core
 /tests/components/homeassistant_green/ @home-assistant/core
 /homeassistant/components/homeassistant_hardware/ @home-assistant/core
@@ -721,10 +674,8 @@ build.json @home-assistant/supervisor
 /tests/components/http/ @home-assistant/core
 /homeassistant/components/huawei_lte/ @scop @fphammerle
 /tests/components/huawei_lte/ @scop @fphammerle
-/homeassistant/components/hue/ @marcelveldt
-/tests/components/hue/ @marcelveldt
-/homeassistant/components/hue_ble/ @flip-dots
-/tests/components/hue_ble/ @flip-dots
+/homeassistant/components/hue/ @balloob @marcelveldt
+/tests/components/hue/ @balloob @marcelveldt
 /homeassistant/components/huisbaasje/ @dennisschroer
 /tests/components/huisbaasje/ @dennisschroer
 /homeassistant/components/humidifier/ @home-assistant/core @Shulyaka
@@ -774,8 +725,6 @@ build.json @home-assistant/supervisor
 /tests/components/improv_ble/ @emontnemery
 /homeassistant/components/incomfort/ @jbouwh
 /tests/components/incomfort/ @jbouwh
-/homeassistant/components/inels/ @epdevlab
-/tests/components/inels/ @epdevlab
 /homeassistant/components/influxdb/ @mdegat01
 /tests/components/influxdb/ @mdegat01
 /homeassistant/components/inkbird/ @bdraco
@@ -798,13 +747,11 @@ build.json @home-assistant/supervisor
 /tests/components/integration/ @dgomes
 /homeassistant/components/intellifire/ @jeeftor
 /tests/components/intellifire/ @jeeftor
-/homeassistant/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
-/tests/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
-/homeassistant/components/intent_script/ @arturpragacz
-/tests/components/intent_script/ @arturpragacz
+/homeassistant/components/intent/ @home-assistant/core @synesthesiam
+/tests/components/intent/ @home-assistant/core @synesthesiam
 /homeassistant/components/intesishome/ @jnimmo
-/homeassistant/components/iometer/ @jukrebs
-/tests/components/iometer/ @jukrebs
+/homeassistant/components/iometer/ @MaestroOnICe
+/tests/components/iometer/ @MaestroOnICe
 /homeassistant/components/ios/ @robbiet480
 /tests/components/ios/ @robbiet480
 /homeassistant/components/iotawatt/ @gtdiehl @jyavenard
@@ -819,8 +766,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/iqvia/ @bachya
 /tests/components/iqvia/ @bachya
 /homeassistant/components/irish_rail_transport/ @ttroy50
-/homeassistant/components/irm_kmi/ @jdejaegh
-/tests/components/irm_kmi/ @jdejaegh
 /homeassistant/components/iron_os/ @tr4nt0r
 /tests/components/iron_os/ @tr4nt0r
 /homeassistant/components/isal/ @bdraco
@@ -879,8 +824,6 @@ build.json @home-assistant/supervisor
 /tests/components/kraken/ @eifinger
 /homeassistant/components/kulersky/ @emlove
 /tests/components/kulersky/ @emlove
-/homeassistant/components/labs/ @home-assistant/core
-/tests/components/labs/ @home-assistant/core
 /homeassistant/components/lacrosse_view/ @IceBotYT
 /tests/components/lacrosse_view/ @IceBotYT
 /homeassistant/components/lamarzocco/ @zweckj
@@ -913,8 +856,6 @@ build.json @home-assistant/supervisor
 /tests/components/lg_netcast/ @Drafteed @splinter98
 /homeassistant/components/lg_thinq/ @LG-ThinQ-Integration
 /tests/components/lg_thinq/ @LG-ThinQ-Integration
-/homeassistant/components/libre_hardware_monitor/ @Sab44
-/tests/components/libre_hardware_monitor/ @Sab44
 /homeassistant/components/lidarr/ @tkdrob
 /tests/components/lidarr/ @tkdrob
 /homeassistant/components/lifx/ @Djelibeybi
@@ -953,8 +894,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/luci/ @mzdrale
 /homeassistant/components/luftdaten/ @fabaff @frenck
 /tests/components/luftdaten/ @fabaff @frenck
-/homeassistant/components/lunatone/ @MoonDevLT
-/tests/components/lunatone/ @MoonDevLT
 /homeassistant/components/lupusec/ @majuss @suaveolent
 /tests/components/lupusec/ @majuss @suaveolent
 /homeassistant/components/lutron/ @cdheiser @wilburCForce
@@ -1000,8 +939,6 @@ build.json @home-assistant/supervisor
 /tests/components/met_eireann/ @DylanGore
 /homeassistant/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
 /tests/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
-/homeassistant/components/meteo_lt/ @xE1H
-/tests/components/meteo_lt/ @xE1H
 /homeassistant/components/meteoalarm/ @rolfberkenbosch
 /homeassistant/components/meteoclimatic/ @adrianmo
 /tests/components/meteoclimatic/ @adrianmo
@@ -1017,8 +954,8 @@ build.json @home-assistant/supervisor
 /tests/components/mill/ @danielhiversen
 /homeassistant/components/min_max/ @gjohansson-ST
 /tests/components/min_max/ @gjohansson-ST
-/homeassistant/components/minecraft_server/ @elmurato @zachdeibert
-/tests/components/minecraft_server/ @elmurato @zachdeibert
+/homeassistant/components/minecraft_server/ @elmurato
+/tests/components/minecraft_server/ @elmurato
 /homeassistant/components/minio/ @tkislan
 /tests/components/minio/ @tkislan
 /homeassistant/components/moat/ @bdraco
@@ -1054,8 +991,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/msteams/ @peroyvind
 /homeassistant/components/mullvad/ @meichthys
 /tests/components/mullvad/ @meichthys
-/homeassistant/components/music_assistant/ @music-assistant @arturpragacz
-/tests/components/music_assistant/ @music-assistant @arturpragacz
+/homeassistant/components/music_assistant/ @music-assistant
+/tests/components/music_assistant/ @music-assistant
 /homeassistant/components/mutesync/ @currentoor
 /tests/components/mutesync/ @currentoor
 /homeassistant/components/my/ @home-assistant/core
@@ -1068,14 +1005,11 @@ build.json @home-assistant/supervisor
 /tests/components/myuplink/ @pajzo @astrandb
 /homeassistant/components/nam/ @bieniu
 /tests/components/nam/ @bieniu
-/homeassistant/components/namecheapdns/ @tr4nt0r
-/tests/components/namecheapdns/ @tr4nt0r
 /homeassistant/components/nanoleaf/ @milanmeu @joostlek
 /tests/components/nanoleaf/ @milanmeu @joostlek
 /homeassistant/components/nasweb/ @nasWebio
 /tests/components/nasweb/ @nasWebio
-/homeassistant/components/nederlandse_spoorwegen/ @YarmoM @heindrichpaul
-/tests/components/nederlandse_spoorwegen/ @YarmoM @heindrichpaul
+/homeassistant/components/nederlandse_spoorwegen/ @YarmoM
 /homeassistant/components/ness_alarm/ @nickw444
 /tests/components/ness_alarm/ @nickw444
 /homeassistant/components/nest/ @allenporter
@@ -1110,8 +1044,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/nilu/ @hfurubotten
 /homeassistant/components/nina/ @DeerMaximum
 /tests/components/nina/ @DeerMaximum
-/homeassistant/components/nintendo_parental_controls/ @pantherale0
-/tests/components/nintendo_parental_controls/ @pantherale0
 /homeassistant/components/nissan_leaf/ @filcole
 /homeassistant/components/noaa_tides/ @jdelaney72
 /homeassistant/components/nobo_hub/ @echoromeo @oyvindwe
@@ -1172,18 +1104,16 @@ build.json @home-assistant/supervisor
 /tests/components/open_meteo/ @frenck
 /homeassistant/components/open_router/ @joostlek
 /tests/components/open_router/ @joostlek
+/homeassistant/components/openai_conversation/ @balloob
+/tests/components/openai_conversation/ @balloob
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
-/homeassistant/components/openevse/ @c00w @firstof9
-/tests/components/openevse/ @c00w @firstof9
 /homeassistant/components/openexchangerates/ @MartinHjelmare
 /tests/components/openexchangerates/ @MartinHjelmare
 /homeassistant/components/opengarage/ @danielhiversen
 /tests/components/opengarage/ @danielhiversen
 /homeassistant/components/openhome/ @bazwilliams
 /tests/components/openhome/ @bazwilliams
-/homeassistant/components/openrgb/ @felipecrs
-/tests/components/openrgb/ @felipecrs
 /homeassistant/components/opensky/ @joostlek
 /tests/components/opensky/ @joostlek
 /homeassistant/components/opentherm_gw/ @mvn23
@@ -1207,8 +1137,8 @@ build.json @home-assistant/supervisor
 /tests/components/ourgroceries/ @OnFreund
 /homeassistant/components/overkiz/ @imicknl
 /tests/components/overkiz/ @imicknl
-/homeassistant/components/overseerr/ @joostlek @AmGarera
-/tests/components/overseerr/ @joostlek @AmGarera
+/homeassistant/components/overseerr/ @joostlek
+/tests/components/overseerr/ @joostlek
 /homeassistant/components/ovo_energy/ @timmo001
 /tests/components/ovo_energy/ @timmo001
 /homeassistant/components/p1_monitor/ @klaasnicolaas
@@ -1247,14 +1177,12 @@ build.json @home-assistant/supervisor
 /tests/components/plex/ @jjlawren
 /homeassistant/components/plugwise/ @CoMPaTech @bouwew
 /tests/components/plugwise/ @CoMPaTech @bouwew
+/homeassistant/components/plum_lightpad/ @ColinHarrington @prystupa
+/tests/components/plum_lightpad/ @ColinHarrington @prystupa
 /homeassistant/components/point/ @fredrike
 /tests/components/point/ @fredrike
-/homeassistant/components/pooldose/ @lmaertin
-/tests/components/pooldose/ @lmaertin
 /homeassistant/components/poolsense/ @haemishkyd
 /tests/components/poolsense/ @haemishkyd
-/homeassistant/components/portainer/ @erwindouna
-/tests/components/portainer/ @erwindouna
 /homeassistant/components/powerfox/ @klaasnicolaas
 /tests/components/powerfox/ @klaasnicolaas
 /homeassistant/components/powerwall/ @bdraco @jrester @daniel-simpson
@@ -1273,8 +1201,9 @@ build.json @home-assistant/supervisor
 /tests/components/prosegur/ @dgomes
 /homeassistant/components/proximity/ @mib1185
 /tests/components/proximity/ @mib1185
-/homeassistant/components/proxmoxve/ @jhollowe @Corbeno @erwindouna
-/tests/components/proxmoxve/ @jhollowe @Corbeno @erwindouna
+/homeassistant/components/proxmoxve/ @jhollowe @Corbeno
+/homeassistant/components/prusalink/ @balloob
+/tests/components/prusalink/ @balloob
 /homeassistant/components/ps4/ @ktnrg45
 /tests/components/ps4/ @ktnrg45
 /homeassistant/components/pterodactyl/ @elmurato
@@ -1368,16 +1297,16 @@ build.json @home-assistant/supervisor
 /tests/components/rflink/ @javicalle
 /homeassistant/components/rfxtrx/ @danielhiversen @elupus @RobBie1221
 /tests/components/rfxtrx/ @danielhiversen @elupus @RobBie1221
-/homeassistant/components/rhasspy/ @synesthesiam
-/tests/components/rhasspy/ @synesthesiam
+/homeassistant/components/rhasspy/ @balloob @synesthesiam
+/tests/components/rhasspy/ @balloob @synesthesiam
 /homeassistant/components/ridwell/ @bachya
 /tests/components/ridwell/ @bachya
 /homeassistant/components/ring/ @sdb9696
 /tests/components/ring/ @sdb9696
 /homeassistant/components/risco/ @OnFreund
 /tests/components/risco/ @OnFreund
-/homeassistant/components/rituals_perfume_genie/ @milanmeu @frenck @quebulm
-/tests/components/rituals_perfume_genie/ @milanmeu @frenck @quebulm
+/homeassistant/components/rituals_perfume_genie/ @milanmeu @frenck
+/tests/components/rituals_perfume_genie/ @milanmeu @frenck
 /homeassistant/components/rmvtransport/ @cgtobi
 /tests/components/rmvtransport/ @cgtobi
 /homeassistant/components/roborock/ @Lash-L @allenporter
@@ -1390,8 +1319,6 @@ build.json @home-assistant/supervisor
 /tests/components/roomba/ @pschmitt @cyr-ius @shenxn @Orhideous
 /homeassistant/components/roon/ @pavoni
 /tests/components/roon/ @pavoni
-/homeassistant/components/route_b_smart_meter/ @SeraphicRav
-/tests/components/route_b_smart_meter/ @SeraphicRav
 /homeassistant/components/rpi_power/ @shenxn @swetoast
 /tests/components/rpi_power/ @shenxn @swetoast
 /homeassistant/components/rss_feed_template/ @home-assistant/core
@@ -1414,10 +1341,6 @@ build.json @home-assistant/supervisor
 /tests/components/samsungtv/ @chemelli74 @epenet
 /homeassistant/components/sanix/ @tomaszsluszniak
 /tests/components/sanix/ @tomaszsluszniak
-/homeassistant/components/satel_integra/ @Tommatheussen
-/tests/components/satel_integra/ @Tommatheussen
-/homeassistant/components/saunum/ @mettolen
-/tests/components/saunum/ @mettolen
 /homeassistant/components/scene/ @home-assistant/core
 /tests/components/scene/ @home-assistant/core
 /homeassistant/components/schedule/ @home-assistant/core
@@ -1463,14 +1386,12 @@ build.json @home-assistant/supervisor
 /tests/components/seventeentrack/ @shaiu
 /homeassistant/components/sfr_box/ @epenet
 /tests/components/sfr_box/ @epenet
-/homeassistant/components/sftp_storage/ @maretodoric
-/tests/components/sftp_storage/ @maretodoric
-/homeassistant/components/sharkiq/ @JeffResc @funkybunch @TheOneOgre
-/tests/components/sharkiq/ @JeffResc @funkybunch @TheOneOgre
+/homeassistant/components/sharkiq/ @JeffResc @funkybunch
+/tests/components/sharkiq/ @JeffResc @funkybunch
 /homeassistant/components/shell_command/ @home-assistant/core
 /tests/components/shell_command/ @home-assistant/core
-/homeassistant/components/shelly/ @bieniu @thecode @chemelli74 @bdraco
-/tests/components/shelly/ @bieniu @thecode @chemelli74 @bdraco
+/homeassistant/components/shelly/ @balloob @bieniu @thecode @chemelli74 @bdraco
+/tests/components/shelly/ @balloob @bieniu @thecode @chemelli74 @bdraco
 /homeassistant/components/shodan/ @fabaff
 /homeassistant/components/sia/ @eavanvalkenburg
 /tests/components/sia/ @eavanvalkenburg
@@ -1521,6 +1442,8 @@ build.json @home-assistant/supervisor
 /tests/components/smhi/ @gjohansson-ST
 /homeassistant/components/smlight/ @tl-sl
 /tests/components/smlight/ @tl-sl
+/homeassistant/components/sms/ @ocalvo
+/tests/components/sms/ @ocalvo
 /homeassistant/components/snapcast/ @luar123
 /tests/components/snapcast/ @luar123
 /homeassistant/components/snmp/ @nmaggioni
@@ -1529,8 +1452,8 @@ build.json @home-assistant/supervisor
 /tests/components/snoo/ @Lash-L
 /homeassistant/components/snooz/ @AustinBrunkhorst
 /tests/components/snooz/ @AustinBrunkhorst
-/homeassistant/components/solaredge/ @frenck @bdraco @tronikos
-/tests/components/solaredge/ @frenck @bdraco @tronikos
+/homeassistant/components/solaredge/ @frenck @bdraco
+/tests/components/solaredge/ @frenck @bdraco
 /homeassistant/components/solaredge_local/ @drobtravels @scheric
 /homeassistant/components/solarlog/ @Ernst79 @dontinelli
 /tests/components/solarlog/ @Ernst79 @dontinelli
@@ -1583,8 +1506,6 @@ build.json @home-assistant/supervisor
 /tests/components/suez_water/ @ooii @jb101010-2
 /homeassistant/components/sun/ @home-assistant/core
 /tests/components/sun/ @home-assistant/core
-/homeassistant/components/sunricher_dali/ @niracler
-/tests/components/sunricher_dali/ @niracler
 /homeassistant/components/supla/ @mwegrzynek
 /homeassistant/components/surepetcare/ @benleb @danielhiversen
 /tests/components/surepetcare/ @benleb @danielhiversen
@@ -1599,8 +1520,8 @@ build.json @home-assistant/supervisor
 /tests/components/switchbee/ @jafar-atili
 /homeassistant/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski @zerzhang
 /tests/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski @zerzhang
-/homeassistant/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur @XiaoLing-git
-/tests/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur @XiaoLing-git
+/homeassistant/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur
+/tests/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur
 /homeassistant/components/switcher_kis/ @thecode @YogevBokobza
 /tests/components/switcher_kis/ @thecode @YogevBokobza
 /homeassistant/components/switchmate/ @danielhiversen @qiz-li
@@ -1617,8 +1538,8 @@ build.json @home-assistant/supervisor
 /tests/components/systemmonitor/ @gjohansson-ST
 /homeassistant/components/tado/ @erwindouna
 /tests/components/tado/ @erwindouna
-/homeassistant/components/tag/ @home-assistant/core
-/tests/components/tag/ @home-assistant/core
+/homeassistant/components/tag/ @balloob @dmulcahey
+/tests/components/tag/ @balloob @dmulcahey
 /homeassistant/components/tailscale/ @frenck
 /tests/components/tailscale/ @frenck
 /homeassistant/components/tailwind/ @frenck
@@ -1706,8 +1627,8 @@ build.json @home-assistant/supervisor
 /tests/components/trafikverket_train/ @gjohansson-ST
 /homeassistant/components/trafikverket_weatherstation/ @gjohansson-ST
 /tests/components/trafikverket_weatherstation/ @gjohansson-ST
-/homeassistant/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
-/tests/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
+/homeassistant/components/transmission/ @engrbm87 @JPHutchins
+/tests/components/transmission/ @engrbm87 @JPHutchins
 /homeassistant/components/trend/ @jpbede
 /tests/components/trend/ @jpbede
 /homeassistant/components/triggercmd/ @rvmey
@@ -1745,8 +1666,6 @@ build.json @home-assistant/supervisor
 /tests/components/uptime_kuma/ @tr4nt0r
 /homeassistant/components/uptimerobot/ @ludeeus @chemelli74
 /tests/components/uptimerobot/ @ludeeus @chemelli74
-/homeassistant/components/usage_prediction/ @home-assistant/core
-/tests/components/usage_prediction/ @home-assistant/core
 /homeassistant/components/usb/ @bdraco
 /tests/components/usb/ @bdraco
 /homeassistant/components/usgs_earthquakes_feed/ @exxamalte
@@ -1761,43 +1680,40 @@ build.json @home-assistant/supervisor
 /tests/components/vallox/ @andre-richter @slovdahl @viiru- @yozik04
 /homeassistant/components/valve/ @home-assistant/core
 /tests/components/valve/ @home-assistant/core
-/homeassistant/components/vegehub/ @thulrus
-/tests/components/vegehub/ @thulrus
+/homeassistant/components/vegehub/ @ghowevege
+/tests/components/vegehub/ @ghowevege
 /homeassistant/components/velbus/ @Cereal2nd @brefra
 /tests/components/velbus/ @Cereal2nd @brefra
-/homeassistant/components/velux/ @Julius2342 @DeerMaximum @pawlizio @wollew
-/tests/components/velux/ @Julius2342 @DeerMaximum @pawlizio @wollew
+/homeassistant/components/velux/ @Julius2342 @DeerMaximum @pawlizio
+/tests/components/velux/ @Julius2342 @DeerMaximum @pawlizio
 /homeassistant/components/venstar/ @garbled1 @jhollowe
 /tests/components/venstar/ @garbled1 @jhollowe
 /homeassistant/components/versasense/ @imstevenxyz
 /homeassistant/components/version/ @ludeeus
 /tests/components/version/ @ludeeus
-/homeassistant/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
-/tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
+/homeassistant/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak
+/tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak
 /homeassistant/components/vicare/ @CFenner
 /tests/components/vicare/ @CFenner
-/homeassistant/components/victron_ble/ @rajlaud
-/tests/components/victron_ble/ @rajlaud
-/homeassistant/components/victron_remote_monitoring/ @AndyTempel
-/tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW
 /tests/components/vilfo/ @ManneW
 /homeassistant/components/vivotek/ @HarlemSquirrel
-/tests/components/vivotek/ @HarlemSquirrel
 /homeassistant/components/vizio/ @raman325
 /tests/components/vizio/ @raman325
 /homeassistant/components/vlc_telnet/ @rodripf @MartinHjelmare
 /tests/components/vlc_telnet/ @rodripf @MartinHjelmare
 /homeassistant/components/vodafone_station/ @paoloantinori @chemelli74
 /tests/components/vodafone_station/ @paoloantinori @chemelli74
-/homeassistant/components/voip/ @synesthesiam @jaminh
-/tests/components/voip/ @synesthesiam @jaminh
+/homeassistant/components/voip/ @balloob @synesthesiam @jaminh
+/tests/components/voip/ @balloob @synesthesiam @jaminh
 /homeassistant/components/volumio/ @OnFreund
 /tests/components/volumio/ @OnFreund
 /homeassistant/components/volvo/ @thomasddn
 /tests/components/volvo/ @thomasddn
-/homeassistant/components/volvooncall/ @molobrakos @svrooij
-/tests/components/volvooncall/ @molobrakos @svrooij
+/homeassistant/components/volvooncall/ @molobrakos
+/tests/components/volvooncall/ @molobrakos
+/homeassistant/components/vulcan/ @Antoni-Czaplicki
+/tests/components/vulcan/ @Antoni-Czaplicki
 /homeassistant/components/wake_on_lan/ @ntilley905
 /tests/components/wake_on_lan/ @ntilley905
 /homeassistant/components/wake_word/ @home-assistant/core @synesthesiam
@@ -1808,12 +1724,9 @@ build.json @home-assistant/supervisor
 /tests/components/waqi/ @joostlek
 /homeassistant/components/water_heater/ @home-assistant/core
 /tests/components/water_heater/ @home-assistant/core
-/homeassistant/components/waterfurnace/ @sdague @masterkoppa
 /homeassistant/components/watergate/ @adam-the-hero
 /tests/components/watergate/ @adam-the-hero
 /homeassistant/components/watson_tts/ @rutkai
-/homeassistant/components/watts/ @theobld-ww @devender-verma-ww @ssi-spyro
-/tests/components/watts/ @theobld-ww @devender-verma-ww @ssi-spyro
 /homeassistant/components/watttime/ @bachya
 /tests/components/watttime/ @bachya
 /homeassistant/components/waze_travel_time/ @eifinger
@@ -1826,8 +1739,6 @@ build.json @home-assistant/supervisor
 /tests/components/weatherflow_cloud/ @jeeftor
 /homeassistant/components/weatherkit/ @tjhorner
 /tests/components/weatherkit/ @tjhorner
-/homeassistant/components/web_rtc/ @home-assistant/core
-/tests/components/web_rtc/ @home-assistant/core
 /homeassistant/components/webdav/ @jpbede
 /tests/components/webdav/ @jpbede
 /homeassistant/components/webhook/ @home-assistant/core
@@ -1867,10 +1778,10 @@ build.json @home-assistant/supervisor
 /tests/components/worldclock/ @fabaff
 /homeassistant/components/ws66i/ @ssaenger
 /tests/components/ws66i/ @ssaenger
-/homeassistant/components/wyoming/ @synesthesiam
-/tests/components/wyoming/ @synesthesiam
-/homeassistant/components/xbox/ @hunterjm @tr4nt0r
-/tests/components/xbox/ @hunterjm @tr4nt0r
+/homeassistant/components/wyoming/ @balloob @synesthesiam
+/tests/components/wyoming/ @balloob @synesthesiam
+/homeassistant/components/xbox/ @hunterjm
+/tests/components/xbox/ @hunterjm
 /homeassistant/components/xiaomi_aqara/ @danielhiversen @syssi
 /tests/components/xiaomi_aqara/ @danielhiversen @syssi
 /homeassistant/components/xiaomi_ble/ @Jc2k @Ernst79

CONTRIBUTING.md

@@ -14,8 +14,5 @@ Still interested? Then you should take a peek at the [developer documentation](h
 
 ## Feature suggestions
 
-If you want to suggest a new feature for Home Assistant (e.g. new integrations), please [start a discussion](https://github.com/orgs/home-assistant/discussions) on GitHub.
-
-## Issue Tracker
-
-If you want to report an issue, please [create an issue](https://github.com/home-assistant/core/issues) on GitHub.
+If you want to suggest a new feature for Home Assistant (e.g., new integrations), please open a thread in our [Community Forum: Feature Requests](https://community.home-assistant.io/c/feature-requests).
+We use [GitHub for tracking issues](https://github.com/home-assistant/core/issues), not for tracking feature requests.

Dockerfile

@@ -4,33 +4,34 @@
 ARG BUILD_FROM
 FROM ${BUILD_FROM}
 
-LABEL \
-    io.hass.type="core" \
-    org.opencontainers.image.authors="The Home Assistant Authors" \
-    org.opencontainers.image.description="Open-source home automation platform running on Python 3" \
-    org.opencontainers.image.documentation="https://www.home-assistant.io/docs/" \
-    org.opencontainers.image.licenses="Apache-2.0" \
-    org.opencontainers.image.source="https://github.com/home-assistant/core" \
-    org.opencontainers.image.title="Home Assistant" \
-    org.opencontainers.image.url="https://www.home-assistant.io/"
-
 # Synchronize with homeassistant/core.py:async_stop
 ENV \
     S6_SERVICES_GRACETIME=240000 \
     UV_SYSTEM_PYTHON=true \
     UV_NO_CACHE=true
 
+ARG QEMU_CPU
+
 # Home Assistant S6-Overlay
 COPY rootfs /
 
-# Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc@sha256:f394f6329f5389a4c9a7fc54b09fdec9621bbb78bf7a672b973440bbdfb02241 /usr/local/bin/go2rtc /bin/go2rtc
-
+# Needs to be redefined inside the FROM statement to be set for RUN commands
+ARG BUILD_ARCH
+# Get go2rtc binary
 RUN \
+    case "${BUILD_ARCH}" in \
+        "aarch64") go2rtc_suffix='arm64' ;; \
+        "armhf") go2rtc_suffix='armv6' ;; \
+        "armv7") go2rtc_suffix='arm' ;; \
+        *) go2rtc_suffix=${BUILD_ARCH} ;; \
+    esac \
+    && curl -L https://github.com/AlexxIT/go2rtc/releases/download/v1.9.9/go2rtc_linux_${go2rtc_suffix} --output /bin/go2rtc \
+    && chmod +x /bin/go2rtc \
     # Verify go2rtc can be executed
-    go2rtc --version \
-    # Install uv
-    && pip3 install uv==0.9.17
+    && go2rtc --version
+
+# Install uv
+RUN pip3 install uv==0.8.9
 
 WORKDIR /usr/src
 

Dockerfile.dev

@@ -3,7 +3,8 @@ FROM mcr.microsoft.com/vscode/devcontainers/base:debian
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
 RUN \
-    apt-get update \
+    curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add - \
+    && apt-get update \
     && DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends \
         # Additional library needed by some tests and accordingly by VScode Tests Discovery
         bluez \
@@ -13,6 +14,7 @@ RUN \
         libavcodec-dev \
         libavdevice-dev \
         libavutil-dev \
+        libgammu-dev \
         libswscale-dev \
         libswresample-dev \
         libavfilter-dev \
@@ -33,24 +35,25 @@ WORKDIR /usr/src
 
 COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 
-USER vscode
+RUN uv python install 3.13.2
 
+USER vscode
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
-RUN --mount=type=bind,source=.python-version,target=.python-version \
-    uv python install \
-    && uv venv $VIRTUAL_ENV
+RUN uv venv $VIRTUAL_ENV
 ENV PATH="$VIRTUAL_ENV/bin:$PATH"
 
+WORKDIR /tmp
+
 # Setup hass-release
 RUN git clone --depth 1 https://github.com/home-assistant/hass-release ~/hass-release \
     && uv pip install -e ~/hass-release/
 
 # Install Python dependencies from requirements
-RUN --mount=type=bind,source=requirements.txt,target=requirements.txt \
-    --mount=type=bind,source=homeassistant/package_constraints.txt,target=homeassistant/package_constraints.txt \
-    --mount=type=bind,source=requirements_test.txt,target=requirements_test.txt \
-    --mount=type=bind,source=requirements_test_pre_commit.txt,target=requirements_test_pre_commit.txt \
-    uv pip install -r requirements.txt -r requirements_test.txt
+COPY requirements.txt ./
+COPY homeassistant/package_constraints.txt homeassistant/package_constraints.txt
+RUN uv pip install -r requirements.txt
+COPY requirements_test.txt requirements_test_pre_commit.txt ./
+RUN uv pip install -r requirements_test.txt
 
 WORKDIR /workspaces
 

build.yaml

@@ -0,0 +1,22 @@
+image: ghcr.io/home-assistant/{arch}-homeassistant
+build_from:
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.05.0
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.05.0
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.05.0
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.05.0
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.05.0
+codenotary:
+  signer: notary@home-assistant.io
+  base_image: notary@home-assistant.io
+cosign:
+  base_identity: https://github.com/home-assistant/docker/.*
+  identity: https://github.com/home-assistant/core/.*
+labels:
+  io.hass.type: core
+  org.opencontainers.image.title: Home Assistant
+  org.opencontainers.image.description: Open-source home automation platform running on Python 3
+  org.opencontainers.image.source: https://github.com/home-assistant/core
+  org.opencontainers.image.authors: The Home Assistant Authors
+  org.opencontainers.image.url: https://www.home-assistant.io/
+  org.opencontainers.image.documentation: https://www.home-assistant.io/docs/
+  org.opencontainers.image.licenses: Apache-2.0

homeassistant/__main__.py

@@ -187,42 +187,36 @@ def main() -> int:
 
     from . import config, runner  # noqa: PLC0415
 
-    # Ensure only one instance runs per config directory
-    with runner.ensure_single_execution(config_dir) as single_execution_lock:
-        # Check if another instance is already running
-        if single_execution_lock.exit_code is not None:
-            return single_execution_lock.exit_code
+    safe_mode = config.safe_mode_enabled(config_dir)
 
-        safe_mode = config.safe_mode_enabled(config_dir)
+    runtime_conf = runner.RuntimeConfig(
+        config_dir=config_dir,
+        verbose=args.verbose,
+        log_rotate_days=args.log_rotate_days,
+        log_file=args.log_file,
+        log_no_color=args.log_no_color,
+        skip_pip=args.skip_pip,
+        skip_pip_packages=args.skip_pip_packages,
+        recovery_mode=args.recovery_mode,
+        debug=args.debug,
+        open_ui=args.open_ui,
+        safe_mode=safe_mode,
+    )
 
-        runtime_conf = runner.RuntimeConfig(
-            config_dir=config_dir,
-            verbose=args.verbose,
-            log_rotate_days=args.log_rotate_days,
-            log_file=args.log_file,
-            log_no_color=args.log_no_color,
-            skip_pip=args.skip_pip,
-            skip_pip_packages=args.skip_pip_packages,
-            recovery_mode=args.recovery_mode,
-            debug=args.debug,
-            open_ui=args.open_ui,
-            safe_mode=safe_mode,
-        )
+    fault_file_name = os.path.join(config_dir, FAULT_LOG_FILENAME)
+    with open(fault_file_name, mode="a", encoding="utf8") as fault_file:
+        faulthandler.enable(fault_file)
+        exit_code = runner.run(runtime_conf)
+        faulthandler.disable()
 
-        fault_file_name = os.path.join(config_dir, FAULT_LOG_FILENAME)
-        with open(fault_file_name, mode="a", encoding="utf8") as fault_file:
-            faulthandler.enable(fault_file)
-            exit_code = runner.run(runtime_conf)
-            faulthandler.disable()
+    # It's possible for the fault file to disappear, so suppress obvious errors
+    with suppress(FileNotFoundError):
+        if os.path.getsize(fault_file_name) == 0:
+            os.remove(fault_file_name)
 
-        # It's possible for the fault file to disappear, so suppress obvious errors
-        with suppress(FileNotFoundError):
-            if os.path.getsize(fault_file_name) == 0:
-                os.remove(fault_file_name)
+    check_threads()
 
-        check_threads()
-
-        return exit_code
+    return exit_code
 
 
 if __name__ == "__main__":

homeassistant/auth/__init__.py

@@ -402,8 +402,6 @@ class AuthManager:
         if user.is_owner:
             raise ValueError("Unable to deactivate the owner")
         await self._store.async_deactivate_user(user)
-        for refresh_token in list(user.refresh_tokens.values()):
-            self.async_remove_refresh_token(refresh_token)
 
     async def async_remove_credentials(self, credentials: models.Credentials) -> None:
         """Remove credentials."""

homeassistant/auth/mfa_modules/notify.py

@@ -6,6 +6,7 @@ Sending HOTP through notify service
 from __future__ import annotations
 
 import asyncio
+from collections import OrderedDict
 import logging
 from typing import Any, cast
 
@@ -26,7 +27,7 @@ from . import (
     SetupFlow,
 )
 
-REQUIREMENTS = ["pyotp==2.9.0"]
+REQUIREMENTS = ["pyotp==2.8.0"]
 
 CONF_MESSAGE = "message"
 
@@ -303,14 +304,13 @@ class NotifySetupFlow(SetupFlow[NotifyAuthModule]):
         if not self._available_notify_services:
             return self.async_abort(reason="no_available_service")
 
-        schema = vol.Schema(
-            {
-                vol.Required("notify_service"): vol.In(self._available_notify_services),
-                vol.Optional("target"): str,
-            }
-        )
+        schema: dict[str, Any] = OrderedDict()
+        schema["notify_service"] = vol.In(self._available_notify_services)
+        schema["target"] = vol.Optional(str)
 
-        return self.async_show_form(step_id="init", data_schema=schema, errors=errors)
+        return self.async_show_form(
+            step_id="init", data_schema=vol.Schema(schema), errors=errors
+        )
 
     async def async_step_setup(
         self, user_input: dict[str, str] | None = None

homeassistant/auth/mfa_modules/totp.py

@@ -20,7 +20,7 @@ from . import (
     SetupFlow,
 )
 
-REQUIREMENTS = ["pyotp==2.9.0", "PyQRCode==1.2.1"]
+REQUIREMENTS = ["pyotp==2.8.0", "PyQRCode==1.2.1"]
 
 CONFIG_SCHEMA = MULTI_FACTOR_AUTH_MODULE_SCHEMA.extend({}, extra=vol.PREVENT_EXTRA)
 
@@ -34,9 +34,6 @@ INPUT_FIELD_CODE = "code"
 
 DUMMY_SECRET = "FPPTH34D4E3MI2HG"
 
-GOOGLE_AUTHENTICATOR_URL = "https://support.google.com/accounts/answer/1066447"
-AUTHY_URL = "https://authy.com/"
-
 
 def _generate_qr_code(data: str) -> str:
     """Generate a base64 PNG string represent QR Code image of data."""
@@ -232,8 +229,6 @@ class TotpSetupFlow(SetupFlow[TotpAuthModule]):
                 "code": self._ota_secret,
                 "url": self._url,
                 "qr_code": self._image,
-                "google_authenticator_url": GOOGLE_AUTHENTICATOR_URL,
-                "authy_url": AUTHY_URL,
             },
             errors=errors,
         )

homeassistant/auth/permissions/events.py

@@ -7,7 +7,6 @@ from typing import Any, Final
 from homeassistant.const import (
     EVENT_COMPONENT_LOADED,
     EVENT_CORE_CONFIG_UPDATE,
-    EVENT_LABS_UPDATED,
     EVENT_LOVELACE_UPDATED,
     EVENT_PANELS_UPDATED,
     EVENT_RECORDER_5MIN_STATISTICS_GENERATED,
@@ -46,7 +45,6 @@ SUBSCRIBE_ALLOWLIST: Final[set[EventType[Any] | str]] = {
     EVENT_STATE_CHANGED,
     EVENT_THEMES_UPDATED,
     EVENT_LABEL_REGISTRY_UPDATED,
-    EVENT_LABS_UPDATED,
     EVENT_CATEGORY_REGISTRY_UPDATED,
     EVENT_FLOOR_REGISTRY_UPDATED,
 }

homeassistant/auth/providers/homeassistant.py

@@ -179,18 +179,12 @@ class Data:
         user_hash = base64.b64decode(found["password"])
 
         # bcrypt.checkpw is timing-safe
-        # With bcrypt 5.0 passing a password longer than 72 bytes raises a ValueError.
-        # Previously the password was silently truncated.
-        # https://github.com/pyca/bcrypt/pull/1000
-        if not bcrypt.checkpw(password.encode()[:72], user_hash):
+        if not bcrypt.checkpw(password.encode(), user_hash):
             raise InvalidAuth
 
     def hash_password(self, password: str, for_storage: bool = False) -> bytes:
         """Encode a password."""
-        # With bcrypt 5.0 passing a password longer than 72 bytes raises a ValueError.
-        # Previously the password was silently truncated.
-        # https://github.com/pyca/bcrypt/pull/1000
-        hashed: bytes = bcrypt.hashpw(password.encode()[:72], bcrypt.gensalt(rounds=12))
+        hashed: bytes = bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))
 
         if for_storage:
             hashed = base64.b64encode(hashed)

homeassistant/bootstrap.py

@@ -176,8 +176,6 @@ FRONTEND_INTEGRATIONS = {
 STAGE_0_INTEGRATIONS = (
     # Load logging and http deps as soon as possible
     ("logging, http deps", LOGGING_AND_HTTP_DEPS_INTEGRATIONS, None),
-    # Setup labs for preview features
-    ("labs", {"labs"}, STAGE_0_SUBSTAGE_TIMEOUT),
     # Setup frontend
     ("frontend", FRONTEND_INTEGRATIONS, None),
     # Setup recorder
@@ -214,7 +212,6 @@ DEFAULT_INTEGRATIONS = {
     "backup",
     "frontend",
     "hardware",
-    "labs",
     "logger",
     "network",
     "system_health",
@@ -619,37 +616,34 @@ async def async_enable_logging(
         ),
     )
 
-    logger = logging.getLogger()
-    logger.setLevel(logging.INFO if verbose else logging.WARNING)
-
+    # Log errors to a file if we have write access to file or config dir
     if log_file is None:
-        default_log_path = hass.config.path(ERROR_LOG_FILENAME)
-        if "SUPERVISOR" in os.environ and "HA_DUPLICATE_LOG_FILE" not in os.environ:
-            # Rename the default log file if it exists, since previous versions created
-            # it even on Supervisor
-            def rename_old_file() -> None:
-                """Rename old log file in executor."""
-                if os.path.isfile(default_log_path):
-                    with contextlib.suppress(OSError):
-                        os.rename(default_log_path, f"{default_log_path}.old")
-
-            await hass.async_add_executor_job(rename_old_file)
-            err_log_path = None
-        else:
-            err_log_path = default_log_path
+        err_log_path = hass.config.path(ERROR_LOG_FILENAME)
     else:
         err_log_path = os.path.abspath(log_file)
 
-    if err_log_path:
+    err_path_exists = os.path.isfile(err_log_path)
+    err_dir = os.path.dirname(err_log_path)
+
+    # Check if we can write to the error log if it exists or that
+    # we can create files in the containing directory if not.
+    if (err_path_exists and os.access(err_log_path, os.W_OK)) or (
+        not err_path_exists and os.access(err_dir, os.W_OK)
+    ):
         err_handler = await hass.async_add_executor_job(
             _create_log_file, err_log_path, log_rotate_days
         )
 
         err_handler.setFormatter(logging.Formatter(fmt, datefmt=FORMAT_DATETIME))
+
+        logger = logging.getLogger()
         logger.addHandler(err_handler)
+        logger.setLevel(logging.INFO if verbose else logging.WARNING)
 
         # Save the log file location for access by other components.
         hass.data[DATA_LOGGING] = err_log_path
+    else:
+        _LOGGER.error("Unable to set up error log %s (access denied)", err_log_path)
 
     async_activate_log_queue_handler(hass)
 
@@ -1003,7 +997,7 @@ class _WatchPendingSetups:
             # We log every LOG_SLOW_STARTUP_INTERVAL until all integrations are done
             # once we take over LOG_SLOW_STARTUP_INTERVAL (60s) to start up
             _LOGGER.warning(
-                "Waiting for integrations to complete setup: %s",
+                "Waiting on integrations to complete setup: %s",
                 self._setup_started,
             )
 

homeassistant/brands/eltako.json

@@ -1,5 +0,0 @@
-{
-  "domain": "eltako",
-  "name": "Eltako",
-  "iot_standards": ["matter"]
-}

homeassistant/brands/fritzbox.json

@@ -1,5 +1,5 @@
 {
   "domain": "fritzbox",
-  "name": "FRITZ!",
+  "name": "FRITZ!Box",
   "integrations": ["fritz", "fritzbox", "fritzbox_callmonitor"]
 }

homeassistant/brands/google.json

@@ -2,11 +2,11 @@
   "domain": "google",
   "name": "Google",
   "integrations": [
-    "google_air_quality",
     "google_assistant",
     "google_assistant_sdk",
     "google_cloud",
     "google_drive",
+    "google_gemini",
     "google_generative_ai_conversation",
     "google_mail",
     "google_maps",
@@ -16,7 +16,6 @@
     "google_tasks",
     "google_translate",
     "google_travel_time",
-    "google_weather",
     "google_wifi",
     "google",
     "nest",

homeassistant/brands/ibm.json

@@ -0,0 +1,5 @@
+{
+  "domain": "ibm",
+  "name": "IBM",
+  "integrations": ["watson_iot", "watson_tts"]
+}

homeassistant/brands/konnected.json

@@ -1,5 +0,0 @@
-{
-  "domain": "konnected",
-  "name": "Konnected",
-  "integrations": ["konnected", "konnected_esphome"]
-}

homeassistant/brands/level.json

@@ -1,5 +0,0 @@
-{
-  "domain": "level",
-  "name": "Level",
-  "iot_standards": ["matter"]
-}

homeassistant/brands/philips.json

@@ -1,5 +1,5 @@
 {
   "domain": "philips",
   "name": "Philips",
-  "integrations": ["dynalite", "hue", "hue_ble", "philips_js"]
+  "integrations": ["dynalite", "hue", "philips_js"]
 }

homeassistant/brands/raspberry_pi.json

@@ -1,5 +1,5 @@
 {
   "domain": "raspberry_pi",
   "name": "Raspberry Pi",
-  "integrations": ["raspberry_pi", "rpi_power", "remote_rpi_gpio"]
+  "integrations": ["raspberry_pi", "rpi_camera", "rpi_power", "remote_rpi_gpio"]
 }

homeassistant/brands/victron.json

@@ -1,5 +0,0 @@
-{
-  "domain": "victron",
-  "name": "Victron",
-  "integrations": ["victron_ble", "victron_remote_monitoring"]
-}

homeassistant/brands/yale.json

@@ -1,5 +1,11 @@
 {
   "domain": "yale",
-  "name": "Yale (non-US/Canada)",
-  "integrations": ["yale", "yalexs_ble", "yale_smart_alarm"]
+  "name": "Yale",
+  "integrations": [
+    "august",
+    "yale_smart_alarm",
+    "yalexs_ble",
+    "yale_home",
+    "yale"
+  ]
 }

homeassistant/brands/yale_august.json

@@ -1,5 +0,0 @@
-{
-  "domain": "yale_august",
-  "name": "Yale August (US/Canada)",
-  "integrations": ["august", "august_ble"]
-}

homeassistant/components/abode/strings.json

@@ -1,70 +1,70 @@
 {
   "config": {
-    "abort": {
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "invalid_mfa_code": "Invalid MFA code"
-    },
     "step": {
+      "user": {
+        "title": "Fill in your Abode login information",
+        "data": {
+          "username": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        }
+      },
       "mfa": {
+        "title": "Enter your MFA code for Abode",
         "data": {
           "mfa_code": "MFA code (6-digits)"
-        },
-        "title": "Enter your MFA code for Abode"
+        }
       },
       "reauth_confirm": {
+        "title": "[%key:component::abode::config::step::user::title%]",
         "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::email%]"
-        },
-        "title": "[%key:component::abode::config::step::user::title%]"
-      },
-      "user": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::email%]"
-        },
-        "title": "Fill in your Abode login information"
+          "username": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        }
       }
+    },
+    "error": {
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_mfa_code": "Invalid MFA code"
+    },
+    "abort": {
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     }
   },
   "services": {
     "capture_image": {
+      "name": "Capture image",
       "description": "Requests a new image capture from a camera device.",
       "fields": {
         "entity_id": {
-          "description": "Entity ID of the camera to request an image from.",
-          "name": "Entity"
+          "name": "Entity",
+          "description": "Entity ID of the camera to request an image from."
         }
-      },
-      "name": "Capture image"
+      }
     },
     "change_setting": {
+      "name": "Change setting",
       "description": "Changes an Abode system setting.",
       "fields": {
         "setting": {
-          "description": "Setting to change.",
-          "name": "Setting"
+          "name": "Setting",
+          "description": "Setting to change."
         },
         "value": {
-          "description": "Value of the setting.",
-          "name": "Value"
+          "name": "Value",
+          "description": "Value of the setting."
         }
-      },
-      "name": "Change setting"
+      }
     },
     "trigger_automation": {
+      "name": "Trigger automation",
       "description": "Triggers an Abode automation.",
       "fields": {
         "entity_id": {
-          "description": "Entity ID of the automation to trigger.",
-          "name": "Entity"
+          "name": "Entity",
+          "description": "Entity ID of the automation to trigger."
         }
-      },
-      "name": "Trigger automation"
+      }
     }
   }
 }

homeassistant/components/acaia/coordinator.py

@@ -8,17 +8,14 @@ import logging
 from aioacaia.acaiascale import AcaiaScale
 from aioacaia.exceptions import AcaiaDeviceNotFound, AcaiaError
 
-from homeassistant.components.bluetooth import async_get_scanner
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ADDRESS
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import CONF_IS_NEW_STYLE_SCALE
 
 SCAN_INTERVAL = timedelta(seconds=15)
-UPDATE_DEBOUNCE_TIME = 0.2
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -40,20 +37,11 @@ class AcaiaCoordinator(DataUpdateCoordinator[None]):
             config_entry=entry,
         )
 
-        debouncer = Debouncer(
-            hass=hass,
-            logger=_LOGGER,
-            cooldown=UPDATE_DEBOUNCE_TIME,
-            immediate=True,
-            function=self.async_update_listeners,
-        )
-
         self._scale = AcaiaScale(
             address_or_ble_device=entry.data[CONF_ADDRESS],
             name=entry.title,
             is_new_style_scale=entry.data[CONF_IS_NEW_STYLE_SCALE],
-            notify_callback=debouncer.async_schedule_call,
-            scanner=async_get_scanner(hass),
+            notify_callback=self.async_update_listeners,
         )
 
     @property

homeassistant/components/acaia/icons.json

@@ -4,20 +4,20 @@
       "timer_running": {
         "default": "mdi:timer",
         "state": {
-          "off": "mdi:timer-off",
-          "on": "mdi:timer-play"
+          "on": "mdi:timer-play",
+          "off": "mdi:timer-off"
         }
       }
     },
     "button": {
+      "tare": {
+        "default": "mdi:scale-balance"
+      },
       "reset_timer": {
         "default": "mdi:timer-refresh"
       },
       "start_stop": {
         "default": "mdi:timer-play"
-      },
-      "tare": {
-        "default": "mdi:scale-balance"
       }
     }
   }

homeassistant/components/acaia/manifest.json

@@ -26,5 +26,5 @@
   "iot_class": "local_push",
   "loggers": ["aioacaia"],
   "quality_scale": "platinum",
-  "requirements": ["aioacaia==0.1.17"]
+  "requirements": ["aioacaia==0.1.14"]
 }

homeassistant/components/acaia/strings.json

@@ -1,5 +1,6 @@
 {
   "config": {
+    "flow_title": "{name}",
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
@@ -9,19 +10,18 @@
       "device_not_found": "Device could not be found.",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
-    "flow_title": "{name}",
     "step": {
       "bluetooth_confirm": {
         "description": "[%key:component::bluetooth::config::step::bluetooth_confirm::description%]"
       },
       "user": {
+        "description": "[%key:component::bluetooth::config::step::user::description%]",
         "data": {
           "address": "[%key:common::config_flow::data::device%]"
         },
         "data_description": {
           "address": "Select Acaia scale you want to set up"
-        },
-        "description": "[%key:component::bluetooth::config::step::user::description%]"
+        }
       }
     }
   },
@@ -32,14 +32,14 @@
       }
     },
     "button": {
+      "tare": {
+        "name": "Tare"
+      },
       "reset_timer": {
         "name": "Reset timer"
       },
       "start_stop": {
         "name": "Start/stop timer"
-      },
-      "tare": {
-        "name": "Tare"
       }
     }
   }

homeassistant/components/accuweather/__init__.py

@@ -2,23 +2,21 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 
 from accuweather import AccuWeather
 
 from homeassistant.components.sensor import DOMAIN as SENSOR_PLATFORM
-from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.const import CONF_API_KEY, CONF_NAME, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DOMAIN
+from .const import DOMAIN, UPDATE_INTERVAL_DAILY_FORECAST, UPDATE_INTERVAL_OBSERVATION
 from .coordinator import (
     AccuWeatherConfigEntry,
     AccuWeatherDailyForecastDataUpdateCoordinator,
     AccuWeatherData,
-    AccuWeatherHourlyForecastDataUpdateCoordinator,
     AccuWeatherObservationDataUpdateCoordinator,
 )
 
@@ -30,6 +28,7 @@ PLATFORMS = [Platform.SENSOR, Platform.WEATHER]
 async def async_setup_entry(hass: HomeAssistant, entry: AccuWeatherConfigEntry) -> bool:
     """Set up AccuWeather as config entry."""
     api_key: str = entry.data[CONF_API_KEY]
+    name: str = entry.data[CONF_NAME]
 
     location_key = entry.unique_id
 
@@ -42,28 +41,26 @@ async def async_setup_entry(hass: HomeAssistant, entry: AccuWeatherConfigEntry)
         hass,
         entry,
         accuweather,
+        name,
+        "observation",
+        UPDATE_INTERVAL_OBSERVATION,
     )
+
     coordinator_daily_forecast = AccuWeatherDailyForecastDataUpdateCoordinator(
         hass,
         entry,
         accuweather,
-    )
-    coordinator_hourly_forecast = AccuWeatherHourlyForecastDataUpdateCoordinator(
-        hass,
-        entry,
-        accuweather,
+        name,
+        "daily forecast",
+        UPDATE_INTERVAL_DAILY_FORECAST,
     )
 
-    await asyncio.gather(
-        coordinator_observation.async_config_entry_first_refresh(),
-        coordinator_daily_forecast.async_config_entry_first_refresh(),
-        coordinator_hourly_forecast.async_config_entry_first_refresh(),
-    )
+    await coordinator_observation.async_config_entry_first_refresh()
+    await coordinator_daily_forecast.async_config_entry_first_refresh()
 
     entry.runtime_data = AccuWeatherData(
         coordinator_observation=coordinator_observation,
         coordinator_daily_forecast=coordinator_daily_forecast,
-        coordinator_hourly_forecast=coordinator_hourly_forecast,
     )
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

homeassistant/components/accuweather/config_flow.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from asyncio import timeout
-from collections.abc import Mapping
 from typing import Any
 
 from accuweather import AccuWeather, ApiError, InvalidApiKeyError, RequestsExceededError
@@ -23,8 +22,6 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
     """Config flow for AccuWeather."""
 
     VERSION = 1
-    _latitude: float | None = None
-    _longitude: float | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -53,7 +50,6 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
                 await self.async_set_unique_id(
                     accuweather.location_key, raise_on_progress=False
                 )
-                self._abort_if_unique_id_configured()
 
                 return self.async_create_entry(
                     title=user_input[CONF_NAME], data=user_input
@@ -77,46 +73,3 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
             ),
             errors=errors,
         )
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle configuration by re-auth."""
-        self._latitude = entry_data[CONF_LATITUDE]
-        self._longitude = entry_data[CONF_LONGITUDE]
-
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Dialog that informs the user that reauth is required."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            websession = async_get_clientsession(self.hass)
-            try:
-                async with timeout(10):
-                    accuweather = AccuWeather(
-                        user_input[CONF_API_KEY],
-                        websession,
-                        latitude=self._latitude,
-                        longitude=self._longitude,
-                    )
-                    await accuweather.async_get_location()
-            except (ApiError, ClientConnectorError, TimeoutError, ClientError):
-                errors["base"] = "cannot_connect"
-            except InvalidApiKeyError:
-                errors["base"] = "invalid_api_key"
-            except RequestsExceededError:
-                errors["base"] = "requests_exceeded"
-            else:
-                return self.async_update_reload_and_abort(
-                    self._get_reauth_entry(), data_updates=user_input
-                )
-
-        return self.async_show_form(
-            step_id="reauth_confirm",
-            data_schema=vol.Schema({vol.Required(CONF_API_KEY): str}),
-            errors=errors,
-        )

homeassistant/components/accuweather/const.py

@@ -69,6 +69,5 @@ POLLEN_CATEGORY_MAP = {
     4: "very_high",
     5: "extreme",
 }
-UPDATE_INTERVAL_OBSERVATION = timedelta(minutes=10)
+UPDATE_INTERVAL_OBSERVATION = timedelta(minutes=40)
 UPDATE_INTERVAL_DAILY_FORECAST = timedelta(hours=6)
-UPDATE_INTERVAL_HOURLY_FORECAST = timedelta(minutes=30)

homeassistant/components/accuweather/coordinator.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from asyncio import timeout
-from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from datetime import timedelta
 import logging
@@ -13,9 +12,7 @@ from accuweather import AccuWeather, ApiError, InvalidApiKeyError, RequestsExcee
 from aiohttp.client_exceptions import ClientConnectorError
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_NAME
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.update_coordinator import (
     DataUpdateCoordinator,
@@ -23,15 +20,9 @@ from homeassistant.helpers.update_coordinator import (
     UpdateFailed,
 )
 
-from .const import (
-    DOMAIN,
-    MANUFACTURER,
-    UPDATE_INTERVAL_DAILY_FORECAST,
-    UPDATE_INTERVAL_HOURLY_FORECAST,
-    UPDATE_INTERVAL_OBSERVATION,
-)
+from .const import DOMAIN, MANUFACTURER
 
-EXCEPTIONS = (ApiError, ClientConnectorError, RequestsExceededError)
+EXCEPTIONS = (ApiError, ClientConnectorError, InvalidApiKeyError, RequestsExceededError)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -42,7 +33,6 @@ class AccuWeatherData:
 
     coordinator_observation: AccuWeatherObservationDataUpdateCoordinator
     coordinator_daily_forecast: AccuWeatherDailyForecastDataUpdateCoordinator
-    coordinator_hourly_forecast: AccuWeatherHourlyForecastDataUpdateCoordinator
 
 
 type AccuWeatherConfigEntry = ConfigEntry[AccuWeatherData]
@@ -53,18 +43,18 @@ class AccuWeatherObservationDataUpdateCoordinator(
 ):
     """Class to manage fetching AccuWeather data API."""
 
-    config_entry: AccuWeatherConfigEntry
-
     def __init__(
         self,
         hass: HomeAssistant,
         config_entry: AccuWeatherConfigEntry,
         accuweather: AccuWeather,
+        name: str,
+        coordinator_type: str,
+        update_interval: timedelta,
     ) -> None:
         """Initialize."""
         self.accuweather = accuweather
         self.location_key = accuweather.location_key
-        name = config_entry.data[CONF_NAME]
 
         if TYPE_CHECKING:
             assert self.location_key is not None
@@ -75,8 +65,8 @@ class AccuWeatherObservationDataUpdateCoordinator(
             hass,
             _LOGGER,
             config_entry=config_entry,
-            name=f"{name} (observation)",
-            update_interval=UPDATE_INTERVAL_OBSERVATION,
+            name=f"{name} ({coordinator_type})",
+            update_interval=update_interval,
         )
 
     async def _async_update_data(self) -> dict[str, Any]:
@@ -90,39 +80,29 @@ class AccuWeatherObservationDataUpdateCoordinator(
                 translation_key="current_conditions_update_error",
                 translation_placeholders={"error": repr(error)},
             ) from error
-        except InvalidApiKeyError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_error",
-                translation_placeholders={"entry": self.config_entry.title},
-            ) from err
 
         _LOGGER.debug("Requests remaining: %d", self.accuweather.requests_remaining)
 
         return result
 
 
-class AccuWeatherForecastDataUpdateCoordinator(
+class AccuWeatherDailyForecastDataUpdateCoordinator(
     TimestampDataUpdateCoordinator[list[dict[str, Any]]]
 ):
-    """Base class for AccuWeather forecast."""
-
-    config_entry: AccuWeatherConfigEntry
+    """Class to manage fetching AccuWeather data API."""
 
     def __init__(
         self,
         hass: HomeAssistant,
         config_entry: AccuWeatherConfigEntry,
         accuweather: AccuWeather,
+        name: str,
         coordinator_type: str,
         update_interval: timedelta,
-        fetch_method: Callable[..., Awaitable[list[dict[str, Any]]]],
     ) -> None:
         """Initialize."""
         self.accuweather = accuweather
         self.location_key = accuweather.location_key
-        self._fetch_method = fetch_method
-        name = config_entry.data[CONF_NAME]
 
         if TYPE_CHECKING:
             assert self.location_key is not None
@@ -138,71 +118,24 @@ class AccuWeatherForecastDataUpdateCoordinator(
         )
 
     async def _async_update_data(self) -> list[dict[str, Any]]:
-        """Update forecast data via library."""
+        """Update data via library."""
         try:
             async with timeout(10):
-                result = await self._fetch_method(language=self.hass.config.language)
+                result = await self.accuweather.async_get_daily_forecast(
+                    language=self.hass.config.language
+                )
         except EXCEPTIONS as error:
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="forecast_update_error",
                 translation_placeholders={"error": repr(error)},
             ) from error
-        except InvalidApiKeyError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_error",
-                translation_placeholders={"entry": self.config_entry.title},
-            ) from err
 
         _LOGGER.debug("Requests remaining: %d", self.accuweather.requests_remaining)
+
         return result
 
 
-class AccuWeatherDailyForecastDataUpdateCoordinator(
-    AccuWeatherForecastDataUpdateCoordinator
-):
-    """Coordinator for daily forecast."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: AccuWeatherConfigEntry,
-        accuweather: AccuWeather,
-    ) -> None:
-        """Initialize."""
-        super().__init__(
-            hass,
-            config_entry,
-            accuweather,
-            "daily forecast",
-            UPDATE_INTERVAL_DAILY_FORECAST,
-            fetch_method=accuweather.async_get_daily_forecast,
-        )
-
-
-class AccuWeatherHourlyForecastDataUpdateCoordinator(
-    AccuWeatherForecastDataUpdateCoordinator
-):
-    """Coordinator for hourly forecast."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: AccuWeatherConfigEntry,
-        accuweather: AccuWeather,
-    ) -> None:
-        """Initialize."""
-        super().__init__(
-            hass,
-            config_entry,
-            accuweather,
-            "hourly forecast",
-            UPDATE_INTERVAL_HOURLY_FORECAST,
-            fetch_method=accuweather.async_get_hourly_forecast,
-        )
-
-
 def _get_device_info(location_key: str, name: str) -> DeviceInfo:
     """Get device info."""
     return DeviceInfo(

homeassistant/components/accuweather/icons.json

@@ -1,9 +1,6 @@
 {
   "entity": {
     "sensor": {
-      "air_quality": {
-        "default": "mdi:air-filter"
-      },
       "cloud_ceiling": {
         "default": "mdi:weather-fog"
       },
@@ -37,6 +34,9 @@
       "thunderstorm_probability_night": {
         "default": "mdi:weather-lightning"
       },
+      "translation_key": {
+        "default": "mdi:air-filter"
+      },
       "tree_pollen": {
         "default": "mdi:tree-outline"
       },

homeassistant/components/accuweather/manifest.json

@@ -7,5 +7,6 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["accuweather"],
-  "requirements": ["accuweather==5.0.0"]
+  "requirements": ["accuweather==4.2.0"],
+  "single_config_entry": true
 }

homeassistant/components/accuweather/strings.json

@@ -1,8 +1,14 @@
 {
   "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_location%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+    "step": {
+      "user": {
+        "data": {
+          "name": "[%key:common::config_flow::data::name%]",
+          "api_key": "[%key:common::config_flow::data::api_key%]",
+          "latitude": "[%key:common::config_flow::data::latitude%]",
+          "longitude": "[%key:common::config_flow::data::longitude%]"
+        }
+      }
     },
     "create_entry": {
       "default": "Some sensors are not enabled by default. You can enable them in the entity registry after the integration configuration."
@@ -11,27 +17,6 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_api_key": "[%key:common::config_flow::error::invalid_api_key%]",
       "requests_exceeded": "The allowed number of requests to the AccuWeather API has been exceeded. You have to wait or change the API key."
-    },
-    "step": {
-      "reauth_confirm": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
-        },
-        "data_description": {
-          "api_key": "[%key:component::accuweather::config::step::user::data_description::api_key%]"
-        }
-      },
-      "user": {
-        "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]",
-          "latitude": "[%key:common::config_flow::data::latitude%]",
-          "longitude": "[%key:common::config_flow::data::longitude%]",
-          "name": "[%key:common::config_flow::data::name%]"
-        },
-        "data_description": {
-          "api_key": "API key generated in the AccuWeather APIs portal."
-        }
-      }
     }
   },
   "entity": {
@@ -120,9 +105,9 @@
       "pressure_tendency": {
         "name": "Pressure tendency",
         "state": {
-          "falling": "Falling",
+          "steady": "Steady",
           "rising": "Rising",
-          "steady": "Steady"
+          "falling": "Falling"
         },
         "state_attributes": {
           "options": {
@@ -227,6 +212,9 @@
       "wet_bulb_temperature": {
         "name": "Wet bulb temperature"
       },
+      "wind_speed": {
+        "name": "[%key:component::weather::entity_component::_::state_attributes::wind_speed::name%]"
+      },
       "wind_chill_temperature": {
         "name": "Wind chill temperature"
       },
@@ -239,9 +227,6 @@
       "wind_gust_speed_night": {
         "name": "Wind gust speed night {forecast_day}"
       },
-      "wind_speed": {
-        "name": "[%key:component::weather::entity_component::_::state_attributes::wind_speed::name%]"
-      },
       "wind_speed_day": {
         "name": "Wind speed day {forecast_day}"
       },
@@ -251,9 +236,6 @@
     }
   },
   "exceptions": {
-    "auth_error": {
-      "message": "Authentication failed for {entry}, please update your API key"
-    },
     "current_conditions_update_error": {
       "message": "An error occurred while retrieving weather current conditions data from the AccuWeather API: {error}"
     },

homeassistant/components/accuweather/weather.py

@@ -45,7 +45,6 @@ from .coordinator import (
     AccuWeatherConfigEntry,
     AccuWeatherDailyForecastDataUpdateCoordinator,
     AccuWeatherData,
-    AccuWeatherHourlyForecastDataUpdateCoordinator,
     AccuWeatherObservationDataUpdateCoordinator,
 )
 
@@ -65,7 +64,6 @@ class AccuWeatherEntity(
     CoordinatorWeatherEntity[
         AccuWeatherObservationDataUpdateCoordinator,
         AccuWeatherDailyForecastDataUpdateCoordinator,
-        AccuWeatherHourlyForecastDataUpdateCoordinator,
     ]
 ):
     """Define an AccuWeather entity."""
@@ -78,7 +76,6 @@ class AccuWeatherEntity(
         super().__init__(
             observation_coordinator=accuweather_data.coordinator_observation,
             daily_coordinator=accuweather_data.coordinator_daily_forecast,
-            hourly_coordinator=accuweather_data.coordinator_hourly_forecast,
         )
 
         self._attr_native_precipitation_unit = UnitOfPrecipitationDepth.MILLIMETERS
@@ -89,13 +86,10 @@ class AccuWeatherEntity(
         self._attr_unique_id = accuweather_data.coordinator_observation.location_key
         self._attr_attribution = ATTRIBUTION
         self._attr_device_info = accuweather_data.coordinator_observation.device_info
-        self._attr_supported_features = (
-            WeatherEntityFeature.FORECAST_DAILY | WeatherEntityFeature.FORECAST_HOURLY
-        )
+        self._attr_supported_features = WeatherEntityFeature.FORECAST_DAILY
 
         self.observation_coordinator = accuweather_data.coordinator_observation
         self.daily_coordinator = accuweather_data.coordinator_daily_forecast
-        self.hourly_coordinator = accuweather_data.coordinator_hourly_forecast
 
     @property
     def condition(self) -> str | None:
@@ -213,32 +207,3 @@ class AccuWeatherEntity(
             }
             for item in self.daily_coordinator.data
         ]
-
-    @callback
-    def _async_forecast_hourly(self) -> list[Forecast] | None:
-        """Return the hourly forecast in native units."""
-        return [
-            {
-                ATTR_FORECAST_TIME: utc_from_timestamp(
-                    item["EpochDateTime"]
-                ).isoformat(),
-                ATTR_FORECAST_CLOUD_COVERAGE: item["CloudCover"],
-                ATTR_FORECAST_HUMIDITY: item["RelativeHumidity"],
-                ATTR_FORECAST_NATIVE_TEMP: item["Temperature"][ATTR_VALUE],
-                ATTR_FORECAST_NATIVE_APPARENT_TEMP: item["RealFeelTemperature"][
-                    ATTR_VALUE
-                ],
-                ATTR_FORECAST_NATIVE_PRECIPITATION: item["TotalLiquid"][ATTR_VALUE],
-                ATTR_FORECAST_PRECIPITATION_PROBABILITY: item[
-                    "PrecipitationProbability"
-                ],
-                ATTR_FORECAST_NATIVE_WIND_SPEED: item["Wind"][ATTR_SPEED][ATTR_VALUE],
-                ATTR_FORECAST_NATIVE_WIND_GUST_SPEED: item["WindGust"][ATTR_SPEED][
-                    ATTR_VALUE
-                ],
-                ATTR_FORECAST_UV_INDEX: item["UVIndex"],
-                ATTR_FORECAST_WIND_BEARING: item["Wind"][ATTR_DIRECTION]["Degrees"],
-                ATTR_FORECAST_CONDITION: CONDITION_MAP.get(item["WeatherIcon"]),
-            }
-            for item in self.hourly_coordinator.data
-        ]

homeassistant/components/acmeda/strings.json

@@ -1,15 +1,15 @@
 {
   "config": {
-    "abort": {
-      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
-    },
     "step": {
       "user": {
+        "title": "Pick a hub to add",
         "data": {
           "id": "Host ID"
-        },
-        "title": "Pick a hub to add"
+        }
       }
+    },
+    "abort": {
+      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
     }
   }
 }

homeassistant/components/actron_air/__init__.py

@@ -1,59 +0,0 @@
-"""The Actron Air integration."""
-
-from actron_neo_api import (
-    ActronAirACSystem,
-    ActronAirAPI,
-    ActronAirAPIError,
-    ActronAirAuthError,
-)
-
-from homeassistant.const import CONF_API_TOKEN, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-
-from .const import _LOGGER, DOMAIN
-from .coordinator import (
-    ActronAirConfigEntry,
-    ActronAirRuntimeData,
-    ActronAirSystemCoordinator,
-)
-
-PLATFORMS = [Platform.CLIMATE, Platform.SWITCH]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
-    """Set up Actron Air integration from a config entry."""
-
-    api = ActronAirAPI(refresh_token=entry.data[CONF_API_TOKEN])
-    systems: list[ActronAirACSystem] = []
-
-    try:
-        systems = await api.get_ac_systems()
-        await api.update_status()
-    except ActronAirAuthError as err:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="auth_error",
-        ) from err
-    except ActronAirAPIError as err:
-        raise ConfigEntryNotReady from err
-
-    system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
-    for system in systems:
-        coordinator = ActronAirSystemCoordinator(hass, entry, api, system)
-        _LOGGER.debug("Setting up coordinator for system: %s", system["serial"])
-        await coordinator.async_config_entry_first_refresh()
-        system_coordinators[system["serial"]] = coordinator
-
-    entry.runtime_data = ActronAirRuntimeData(
-        api=api,
-        system_coordinators=system_coordinators,
-    )
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/actron_air/climate.py

@@ -1,219 +0,0 @@
-"""Climate platform for Actron Air integration."""
-
-from typing import Any
-
-from actron_neo_api import ActronAirStatus, ActronAirZone
-
-from homeassistant.components.climate import (
-    FAN_AUTO,
-    FAN_HIGH,
-    FAN_LOW,
-    FAN_MEDIUM,
-    ClimateEntity,
-    ClimateEntityFeature,
-    HVACMode,
-)
-from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity, ActronAirZoneEntity
-
-PARALLEL_UPDATES = 0
-
-FAN_MODE_MAPPING_ACTRONAIR_TO_HA = {
-    "AUTO": FAN_AUTO,
-    "LOW": FAN_LOW,
-    "MED": FAN_MEDIUM,
-    "HIGH": FAN_HIGH,
-}
-FAN_MODE_MAPPING_HA_TO_ACTRONAIR = {
-    v: k for k, v in FAN_MODE_MAPPING_ACTRONAIR_TO_HA.items()
-}
-HVAC_MODE_MAPPING_ACTRONAIR_TO_HA = {
-    "COOL": HVACMode.COOL,
-    "HEAT": HVACMode.HEAT,
-    "FAN": HVACMode.FAN_ONLY,
-    "AUTO": HVACMode.AUTO,
-    "OFF": HVACMode.OFF,
-}
-HVAC_MODE_MAPPING_HA_TO_ACTRONAIR = {
-    v: k for k, v in HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.items()
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ActronAirConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Actron Air climate entities."""
-    system_coordinators = entry.runtime_data.system_coordinators
-    entities: list[ClimateEntity] = []
-
-    for coordinator in system_coordinators.values():
-        status = coordinator.data
-        entities.append(ActronSystemClimate(coordinator))
-
-        entities.extend(
-            ActronZoneClimate(coordinator, zone)
-            for zone in status.remote_zone_info
-            if zone.exists
-        )
-
-    async_add_entities(entities)
-
-
-class ActronAirClimateEntity(ClimateEntity):
-    """Base class for Actron Air climate entities."""
-
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.FAN_MODE
-        | ClimateEntityFeature.TURN_ON
-        | ClimateEntityFeature.TURN_OFF
-    )
-    _attr_name = None
-    _attr_fan_modes = list(FAN_MODE_MAPPING_ACTRONAIR_TO_HA.values())
-    _attr_hvac_modes = list(HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.values())
-
-
-class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
-    """Representation of the Actron Air system."""
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-    ) -> None:
-        """Initialize an Actron Air unit."""
-        super().__init__(coordinator)
-        self._attr_unique_id = self._serial_number
-
-    @property
-    def min_temp(self) -> float:
-        """Return the minimum temperature that can be set."""
-        return self._status.min_temp
-
-    @property
-    def max_temp(self) -> float:
-        """Return the maximum temperature that can be set."""
-        return self._status.max_temp
-
-    @property
-    def _status(self) -> ActronAirStatus:
-        """Get the current status from the coordinator."""
-        return self.coordinator.data
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return the current HVAC mode."""
-        if not self._status.user_aircon_settings.is_on:
-            return HVACMode.OFF
-
-        mode = self._status.user_aircon_settings.mode
-        return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
-
-    @property
-    def fan_mode(self) -> str | None:
-        """Return the current fan mode."""
-        fan_mode = self._status.user_aircon_settings.base_fan_mode
-        return FAN_MODE_MAPPING_ACTRONAIR_TO_HA.get(fan_mode)
-
-    @property
-    def current_humidity(self) -> float:
-        """Return the current humidity."""
-        return self._status.master_info.live_humidity_pc
-
-    @property
-    def current_temperature(self) -> float:
-        """Return the current temperature."""
-        return self._status.master_info.live_temp_c
-
-    @property
-    def target_temperature(self) -> float:
-        """Return the target temperature."""
-        return self._status.user_aircon_settings.temperature_setpoint_cool_c
-
-    async def async_set_fan_mode(self, fan_mode: str) -> None:
-        """Set a new fan mode."""
-        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode)
-        await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
-
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set the HVAC mode."""
-        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR.get(hvac_mode)
-        await self._status.ac_system.set_system_mode(ac_mode)
-
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set the temperature."""
-        temp = kwargs.get(ATTR_TEMPERATURE)
-        await self._status.user_aircon_settings.set_temperature(temperature=temp)
-
-
-class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
-    """Representation of a zone within the Actron Air system."""
-
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.TURN_ON
-        | ClimateEntityFeature.TURN_OFF
-    )
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        zone: ActronAirZone,
-    ) -> None:
-        """Initialize an Actron Air unit."""
-        super().__init__(coordinator, zone)
-        self._attr_unique_id: str = self._zone_identifier
-
-    @property
-    def min_temp(self) -> float:
-        """Return the minimum temperature that can be set."""
-        return self._zone.min_temp
-
-    @property
-    def max_temp(self) -> float:
-        """Return the maximum temperature that can be set."""
-        return self._zone.max_temp
-
-    @property
-    def _zone(self) -> ActronAirZone:
-        """Get the current zone data from the coordinator."""
-        status = self.coordinator.data
-        return status.zones[self._zone_id]
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """Return the current HVAC mode."""
-        if self._zone.is_active:
-            mode = self._zone.hvac_mode
-            return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
-        return HVACMode.OFF
-
-    @property
-    def current_humidity(self) -> float | None:
-        """Return the current humidity."""
-        return self._zone.humidity
-
-    @property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature."""
-        return self._zone.live_temp_c
-
-    @property
-    def target_temperature(self) -> float | None:
-        """Return the target temperature."""
-        return self._zone.temperature_setpoint_cool_c
-
-    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set the HVAC mode."""
-        is_enabled = hvac_mode != HVACMode.OFF
-        await self._zone.enable(is_enabled)
-
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set the temperature."""
-        await self._zone.set_temperature(temperature=kwargs.get(ATTR_TEMPERATURE))

homeassistant/components/actron_air/config_flow.py

@@ -1,156 +0,0 @@
-"""Setup config flow for Actron Air integration."""
-
-import asyncio
-from collections.abc import Mapping
-from typing import Any
-
-from actron_neo_api import ActronAirAPI, ActronAirAuthError
-
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_TOKEN
-from homeassistant.exceptions import HomeAssistantError
-
-from .const import _LOGGER, DOMAIN
-
-
-class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Actron Air."""
-
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        self._api: ActronAirAPI | None = None
-        self._device_code: str | None = None
-        self._user_code: str = ""
-        self._verification_uri: str = ""
-        self._expires_minutes: str = "30"
-        self.login_task: asyncio.Task | None = None
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        if self._api is None:
-            _LOGGER.debug("Initiating device authorization")
-            self._api = ActronAirAPI()
-            try:
-                device_code_response = await self._api.request_device_code()
-            except ActronAirAuthError as err:
-                _LOGGER.error("OAuth2 flow failed: %s", err)
-                return self.async_abort(reason="oauth2_error")
-
-            self._device_code = device_code_response["device_code"]
-            self._user_code = device_code_response["user_code"]
-            self._verification_uri = device_code_response["verification_uri_complete"]
-            self._expires_minutes = str(device_code_response["expires_in"] // 60)
-
-        async def _wait_for_authorization() -> None:
-            """Wait for the user to authorize the device."""
-            assert self._api is not None
-            assert self._device_code is not None
-            _LOGGER.debug("Waiting for device authorization")
-            try:
-                await self._api.poll_for_token(self._device_code)
-                _LOGGER.debug("Authorization successful")
-            except ActronAirAuthError as ex:
-                _LOGGER.exception("Error while waiting for device authorization")
-                raise CannotConnect from ex
-
-        _LOGGER.debug("Checking login task")
-        if self.login_task is None:
-            _LOGGER.debug("Creating task for device authorization")
-            self.login_task = self.hass.async_create_task(_wait_for_authorization())
-
-        if self.login_task.done():
-            _LOGGER.debug("Login task is done, checking results")
-            if exception := self.login_task.exception():
-                if isinstance(exception, CannotConnect):
-                    return self.async_show_progress_done(
-                        next_step_id="connection_error"
-                    )
-                return self.async_show_progress_done(next_step_id="timeout")
-            return self.async_show_progress_done(next_step_id="finish_login")
-
-        return self.async_show_progress(
-            step_id="user",
-            progress_action="wait_for_authorization",
-            description_placeholders={
-                "user_code": self._user_code,
-                "verification_uri": self._verification_uri,
-                "expires_minutes": self._expires_minutes,
-            },
-            progress_task=self.login_task,
-        )
-
-    async def async_step_finish_login(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the finalization of login."""
-        _LOGGER.debug("Finalizing authorization")
-        assert self._api is not None
-
-        try:
-            user_data = await self._api.get_user_info()
-        except ActronAirAuthError as err:
-            _LOGGER.error("Error getting user info: %s", err)
-            return self.async_abort(reason="oauth2_error")
-
-        unique_id = str(user_data["id"])
-        await self.async_set_unique_id(unique_id)
-
-        # Check if this is a reauth flow
-        if self.source == SOURCE_REAUTH:
-            self._abort_if_unique_id_mismatch(reason="wrong_account")
-            return self.async_update_reload_and_abort(
-                self._get_reauth_entry(),
-                data_updates={CONF_API_TOKEN: self._api.refresh_token_value},
-            )
-
-        self._abort_if_unique_id_configured()
-        return self.async_create_entry(
-            title=user_data["email"],
-            data={CONF_API_TOKEN: self._api.refresh_token_value},
-        )
-
-    async def async_step_timeout(
-        self,
-        user_input: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Handle issues that need transition await from progress step."""
-        if user_input is None:
-            return self.async_show_form(
-                step_id="timeout",
-            )
-        del self.login_task
-        return await self.async_step_user()
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reauthentication request."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Confirm reauth dialog."""
-        if user_input is not None:
-            return await self.async_step_user()
-
-        return self.async_show_form(step_id="reauth_confirm")
-
-    async def async_step_connection_error(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle connection error from progress step."""
-        if user_input is None:
-            return self.async_show_form(step_id="connection_error")
-
-        # Reset state and try again
-        self._api = None
-        self._device_code = None
-        self.login_task = None
-        return await self.async_step_user()
-
-
-class CannotConnect(HomeAssistantError):
-    """Error to indicate we cannot connect."""

homeassistant/components/actron_air/const.py

@@ -1,6 +0,0 @@
-"""Constants used by Actron Air integration."""
-
-import logging
-
-_LOGGER = logging.getLogger(__package__)
-DOMAIN = "actron_air"

homeassistant/components/actron_air/coordinator.py

@@ -1,87 +0,0 @@
-"""Coordinator for Actron Air integration."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import timedelta
-
-from actron_neo_api import (
-    ActronAirACSystem,
-    ActronAirAPI,
-    ActronAirAPIError,
-    ActronAirAuthError,
-    ActronAirStatus,
-)
-
-from homeassistant.config_entries import ConfigEntry
-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 .const import _LOGGER, DOMAIN
-
-SCAN_INTERVAL = timedelta(seconds=30)
-STALE_DEVICE_TIMEOUT = timedelta(minutes=5)
-ERROR_NO_SYSTEMS_FOUND = "no_systems_found"
-ERROR_UNKNOWN = "unknown_error"
-
-
-@dataclass
-class ActronAirRuntimeData:
-    """Runtime data for the Actron Air integration."""
-
-    api: ActronAirAPI
-    system_coordinators: dict[str, ActronAirSystemCoordinator]
-
-
-type ActronAirConfigEntry = ConfigEntry[ActronAirRuntimeData]
-
-
-class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
-    """System coordinator for Actron Air integration."""
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        entry: ActronAirConfigEntry,
-        api: ActronAirAPI,
-        system: ActronAirACSystem,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            name="Actron Air Status",
-            update_interval=SCAN_INTERVAL,
-            config_entry=entry,
-        )
-        self.system = system
-        self.serial_number = system["serial"]
-        self.api = api
-        self.status = self.api.state_manager.get_status(self.serial_number)
-        self.last_seen = dt_util.utcnow()
-
-    async def _async_update_data(self) -> ActronAirStatus:
-        """Fetch updates and merge incremental changes into the full state."""
-        try:
-            await self.api.update_status()
-        except ActronAirAuthError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_error",
-            ) from err
-        except ActronAirAPIError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="update_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-
-        self.status = self.api.state_manager.get_status(self.serial_number)
-        self.last_seen = dt_util.utcnow()
-        return self.status
-
-    def is_device_stale(self) -> bool:
-        """Check if a device is stale (not seen for a while)."""
-        return (dt_util.utcnow() - self.last_seen) > STALE_DEVICE_TIMEOUT

homeassistant/components/actron_air/entity.py

@@ -1,63 +0,0 @@
-"""Base entity classes for Actron Air integration."""
-
-from actron_neo_api import ActronAirZone
-
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import ActronAirSystemCoordinator
-
-
-class ActronAirEntity(CoordinatorEntity[ActronAirSystemCoordinator]):
-    """Base class for Actron Air entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(self, coordinator: ActronAirSystemCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._serial_number = coordinator.serial_number
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return not self.coordinator.is_device_stale()
-
-
-class ActronAirAcEntity(ActronAirEntity):
-    """Base class for Actron Air entities."""
-
-    def __init__(self, coordinator: ActronAirSystemCoordinator) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, self._serial_number)},
-            name=coordinator.data.ac_system.system_name,
-            manufacturer="Actron Air",
-            model_id=coordinator.data.ac_system.master_wc_model,
-            sw_version=coordinator.data.ac_system.master_wc_firmware_version,
-            serial_number=self._serial_number,
-        )
-
-
-class ActronAirZoneEntity(ActronAirEntity):
-    """Base class for Actron Air zone entities."""
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        zone: ActronAirZone,
-    ) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._zone_id: int = zone.zone_id
-        self._zone_identifier = f"{self._serial_number}_zone_{zone.zone_id}"
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, self._zone_identifier)},
-            name=zone.title,
-            manufacturer="Actron Air",
-            model="Zone",
-            suggested_area=zone.title,
-            via_device=(DOMAIN, self._serial_number),
-        )

homeassistant/components/actron_air/icons.json

@@ -1,30 +0,0 @@
-{
-  "entity": {
-    "switch": {
-      "away_mode": {
-        "default": "mdi:home-export-outline",
-        "state": {
-          "off": "mdi:home-import-outline"
-        }
-      },
-      "continuous_fan": {
-        "default": "mdi:fan",
-        "state": {
-          "off": "mdi:fan-off"
-        }
-      },
-      "quiet_mode": {
-        "default": "mdi:volume-low",
-        "state": {
-          "off": "mdi:volume-high"
-        }
-      },
-      "turbo_mode": {
-        "default": "mdi:fan-plus",
-        "state": {
-          "off": "mdi:fan"
-        }
-      }
-    }
-  }
-}

homeassistant/components/actron_air/manifest.json

@@ -1,17 +0,0 @@
-{
-  "domain": "actron_air",
-  "name": "Actron Air",
-  "codeowners": ["@kclif9", "@JagadishDhanamjayam"],
-  "config_flow": true,
-  "dhcp": [
-    {
-      "hostname": "neo-*",
-      "macaddress": "FC0FE7*"
-    }
-  ],
-  "documentation": "https://www.home-assistant.io/integrations/actron_air",
-  "integration_type": "hub",
-  "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["actron-neo-api==0.4.1"]
-}

homeassistant/components/actron_air/quality_scale.yaml

@@ -1,78 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: This integration does not have custom service 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: This integration does not have custom service actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: This integration does not subscribe to external 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: todo
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: No options flow
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow: done
-  test-coverage: todo
-
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: This integration uses DHCP discovery, however is cloud polling. Therefore there is no information to update.
-  discovery: done
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: done
-  dynamic-devices: todo
-  entity-category:
-    status: exempt
-    comment: This integration does not use entity categories.
-  entity-device-class:
-    status: exempt
-    comment: This integration does not use entity device classes.
-  entity-disabled-by-default:
-    status: exempt
-    comment: Not required for this integration at this stage.
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: This integration does not have any known issues that require repair.
-  stale-devices: todo
-
-  # Platinum
-  async-dependency: done
-  inject-websession: todo
-  strict-typing: todo

homeassistant/components/actron_air/strings.json

@@ -1,59 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
-      "oauth2_error": "Failed to start authentication flow",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "wrong_account": "You must reauthenticate with the same Actron Air account that was originally configured."
-    },
-    "error": {
-      "oauth2_error": "Failed to start authentication flow. Please try again later."
-    },
-    "progress": {
-      "wait_for_authorization": "To authenticate, open the following URL and login at Actron Air:\n{verification_uri}\nIf the code is not automatically copied, paste the following code to authorize the integration:\n\n```{user_code}```\n\n\nThe login attempt will time out after {expires_minutes} minutes."
-    },
-    "step": {
-      "connection_error": {
-        "data": {},
-        "description": "Failed to connect to Actron Air. Please check your internet connection and try again.",
-        "title": "Connection error"
-      },
-      "reauth_confirm": {
-        "description": "Your Actron Air authentication has expired. Select continue to reauthenticate with your Actron Air account. You will be prompted to log in again to restore the connection.",
-        "title": "Authentication expired"
-      },
-      "timeout": {
-        "data": {},
-        "description": "The authentication process timed out. Please try again.",
-        "title": "Authentication timeout"
-      },
-      "user": {
-        "title": "Actron Air Authentication"
-      }
-    }
-  },
-  "entity": {
-    "switch": {
-      "away_mode": {
-        "name": "Away mode"
-      },
-      "continuous_fan": {
-        "name": "Continuous fan"
-      },
-      "quiet_mode": {
-        "name": "Quiet mode"
-      },
-      "turbo_mode": {
-        "name": "Turbo mode"
-      }
-    }
-  },
-  "exceptions": {
-    "auth_error": {
-      "message": "Authentication failed, please reauthenticate"
-    },
-    "update_error": {
-      "message": "An error occurred while retrieving data from the Actron Air API: {error}"
-    }
-  }
-}

homeassistant/components/actron_air/switch.py

@@ -1,102 +0,0 @@
-"""Switch platform for Actron Air integration."""
-
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
-from typing import Any
-
-from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity
-
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class ActronAirSwitchEntityDescription(SwitchEntityDescription):
-    """Class describing Actron Air switch entities."""
-
-    is_on_fn: Callable[[ActronAirSystemCoordinator], bool]
-    set_fn: Callable[[ActronAirSystemCoordinator, bool], Awaitable[None]]
-    is_supported_fn: Callable[[ActronAirSystemCoordinator], bool] = lambda _: True
-
-
-SWITCHES: tuple[ActronAirSwitchEntityDescription, ...] = (
-    ActronAirSwitchEntityDescription(
-        key="away_mode",
-        translation_key="away_mode",
-        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.away_mode,
-        set_fn=lambda coordinator,
-        enabled: coordinator.data.user_aircon_settings.set_away_mode(enabled),
-    ),
-    ActronAirSwitchEntityDescription(
-        key="continuous_fan",
-        translation_key="continuous_fan",
-        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.continuous_fan_enabled,
-        set_fn=lambda coordinator,
-        enabled: coordinator.data.user_aircon_settings.set_continuous_mode(enabled),
-    ),
-    ActronAirSwitchEntityDescription(
-        key="quiet_mode",
-        translation_key="quiet_mode",
-        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.quiet_mode_enabled,
-        set_fn=lambda coordinator,
-        enabled: coordinator.data.user_aircon_settings.set_quiet_mode(enabled),
-    ),
-    ActronAirSwitchEntityDescription(
-        key="turbo_mode",
-        translation_key="turbo_mode",
-        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_enabled,
-        set_fn=lambda coordinator,
-        enabled: coordinator.data.user_aircon_settings.set_turbo_mode(enabled),
-        is_supported_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_supported,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ActronAirConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Actron Air switch entities."""
-    system_coordinators = entry.runtime_data.system_coordinators
-    async_add_entities(
-        ActronAirSwitch(coordinator, description)
-        for coordinator in system_coordinators.values()
-        for description in SWITCHES
-        if description.is_supported_fn(coordinator)
-    )
-
-
-class ActronAirSwitch(ActronAirAcEntity, SwitchEntity):
-    """Actron Air switch."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    entity_description: ActronAirSwitchEntityDescription
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        description: ActronAirSwitchEntityDescription,
-    ) -> None:
-        """Initialize the switch."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.serial_number}_{description.key}"
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if the switch is on."""
-        return self.entity_description.is_on_fn(self.coordinator)
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the switch on."""
-        await self.entity_description.set_fn(self.coordinator, True)
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the switch off."""
-        await self.entity_description.set_fn(self.coordinator, False)

homeassistant/components/adax/config_flow.py

@@ -17,11 +17,6 @@ from homeassistant.const import (
     CONF_UNIQUE_ID,
 )
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.selector import (
-    TextSelector,
-    TextSelectorConfig,
-    TextSelectorType,
-)
 
 from .const import (
     ACCOUNT_ID,
@@ -71,15 +66,7 @@ class AdaxConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle the local step."""
         data_schema = vol.Schema(
-            {
-                vol.Required(WIFI_SSID): str,
-                vol.Required(WIFI_PSWD): TextSelector(
-                    TextSelectorConfig(
-                        type=TextSelectorType.PASSWORD,
-                        autocomplete="current-password",
-                    ),
-                ),
-            }
+            {vol.Required(WIFI_SSID): str, vol.Required(WIFI_PSWD): str}
         )
         if user_input is None:
             return self.async_show_form(

homeassistant/components/adax/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/adax",
   "iot_class": "local_polling",
   "loggers": ["adax", "adax_local"],
-  "requirements": ["adax==0.4.0", "Adax-local==0.3.0"]
+  "requirements": ["adax==0.4.0", "Adax-local==0.1.5"]
 }

homeassistant/components/adax/sensor.py

@@ -2,16 +2,14 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from typing import cast
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
-    SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import UnitOfEnergy, UnitOfTemperature
+from homeassistant.const import UnitOfEnergy
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -22,74 +20,44 @@ from .const import CONNECTION_TYPE, DOMAIN, LOCAL
 from .coordinator import AdaxCloudCoordinator
 
 
-@dataclass(kw_only=True, frozen=True)
-class AdaxSensorDescription(SensorEntityDescription):
-    """Describes Adax sensor entity."""
-
-    data_key: str
-
-
-SENSORS: tuple[AdaxSensorDescription, ...] = (
-    AdaxSensorDescription(
-        key="temperature",
-        data_key="temperature",
-        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=1,
-    ),
-    AdaxSensorDescription(
-        key="energy",
-        data_key="energyWh",
-        device_class=SensorDeviceClass.ENERGY,
-        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        suggested_display_precision=3,
-    ),
-)
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: AdaxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Adax sensors with config flow."""
+    """Set up the Adax energy sensors with config flow."""
     if entry.data.get(CONNECTION_TYPE) != LOCAL:
         cloud_coordinator = cast(AdaxCloudCoordinator, entry.runtime_data)
 
         # Create individual energy sensors for each device
         async_add_entities(
-            [
-                AdaxSensor(cloud_coordinator, entity_description, device_id)
-                for device_id in cloud_coordinator.data
-                for entity_description in SENSORS
-            ]
+            AdaxEnergySensor(cloud_coordinator, device_id)
+            for device_id in cloud_coordinator.data
         )
 
 
-class AdaxSensor(CoordinatorEntity[AdaxCloudCoordinator], SensorEntity):
-    """Representation of an Adax sensor."""
+class AdaxEnergySensor(CoordinatorEntity[AdaxCloudCoordinator], SensorEntity):
+    """Representation of an Adax energy sensor."""
 
-    entity_description: AdaxSensorDescription
     _attr_has_entity_name = True
+    _attr_translation_key = "energy"
+    _attr_device_class = SensorDeviceClass.ENERGY
+    _attr_native_unit_of_measurement = UnitOfEnergy.WATT_HOUR
+    _attr_suggested_unit_of_measurement = UnitOfEnergy.KILO_WATT_HOUR
+    _attr_state_class = SensorStateClass.TOTAL_INCREASING
+    _attr_suggested_display_precision = 3
 
     def __init__(
         self,
         coordinator: AdaxCloudCoordinator,
-        entity_description: AdaxSensorDescription,
         device_id: str,
     ) -> None:
-        """Initialize the sensor."""
+        """Initialize the energy sensor."""
         super().__init__(coordinator)
-        self.entity_description = entity_description
         self._device_id = device_id
         room = coordinator.data[device_id]
 
-        self._attr_unique_id = (
-            f"{room['homeId']}_{device_id}_{self.entity_description.key}"
-        )
+        self._attr_unique_id = f"{room['homeId']}_{device_id}_energy"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, device_id)},
             name=room["name"],
@@ -100,14 +68,10 @@ class AdaxSensor(CoordinatorEntity[AdaxCloudCoordinator], SensorEntity):
     def available(self) -> bool:
         """Return True if entity is available."""
         return (
-            super().available
-            and self.entity_description.data_key
-            in self.coordinator.data[self._device_id]
+            super().available and "energyWh" in self.coordinator.data[self._device_id]
         )
 
     @property
-    def native_value(self) -> int | float | None:
+    def native_value(self) -> int:
         """Return the native value of the sensor."""
-        return self.coordinator.data[self._device_id].get(
-            self.entity_description.data_key
-        )
+        return int(self.coordinator.data[self._device_id]["energyWh"])

homeassistant/components/adax/strings.json

@@ -1,34 +1,34 @@
 {
   "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "heater_not_available": "Heater not available. Try to reset the heater by pressing + and OK for some seconds.",
-      "heater_not_found": "Heater not found. Try to move the heater closer to Home Assistant computer.",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
-    },
     "step": {
-      "cloud": {
-        "data": {
-          "account_id": "Account ID",
-          "password": "[%key:common::config_flow::data::password%]"
-        }
-      },
-      "local": {
-        "data": {
-          "wifi_pswd": "Wi-Fi password",
-          "wifi_ssid": "Wi-Fi SSID"
-        },
-        "description": "Reset the heater by pressing + and OK until display shows 'Reset'. Then press and hold OK button on the heater until the blue LED starts blinking before pressing Submit. Configuring heater might take some minutes."
-      },
       "user": {
         "data": {
           "connection_type": "Select connection type"
         },
         "description": "Select connection type. Local requires heaters with Bluetooth"
+      },
+      "local": {
+        "data": {
+          "wifi_ssid": "Wi-Fi SSID",
+          "wifi_pswd": "Wi-Fi password"
+        },
+        "description": "Reset the heater by pressing + and OK until display shows 'Reset'. Then press and hold OK button on the heater until the blue LED starts blinking before pressing Submit. Configuring heater might take some minutes."
+      },
+      "cloud": {
+        "data": {
+          "account_id": "Account ID",
+          "password": "[%key:common::config_flow::data::password%]"
+        }
       }
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "heater_not_available": "Heater not available. Try to reset the heater by pressing + and OK for some seconds.",
+      "heater_not_found": "Heater not found. Try to move the heater closer to Home Assistant computer.",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
     }
   }
 }

homeassistant/components/adguard/__init__.py

@@ -45,7 +45,7 @@ SERVICE_REFRESH_SCHEMA = vol.Schema(
     {vol.Optional(CONF_FORCE, default=False): cv.boolean}
 )
 
-PLATFORMS = [Platform.SENSOR, Platform.SWITCH, Platform.UPDATE]
+PLATFORMS = [Platform.SENSOR, Platform.SWITCH]
 type AdGuardConfigEntry = ConfigEntry[AdGuardData]
 
 

homeassistant/components/adguard/entity.py

@@ -52,7 +52,7 @@ class AdGuardHomeEntity(Entity):
     def device_info(self) -> DeviceInfo:
         """Return device information about this AdGuard Home instance."""
         if self._entry.source == SOURCE_HASSIO:
-            config_url = "homeassistant://app/a0d7b954_adguard"
+            config_url = "homeassistant://hassio/ingress/a0d7b954_adguard"
         elif self.adguard.tls:
             config_url = f"https://{self.adguard.host}:{self.adguard.port}"
         else:

homeassistant/components/adguard/icons.json

@@ -1,9 +1,6 @@
 {
   "entity": {
     "sensor": {
-      "average_processing_speed": {
-        "default": "mdi:speedometer"
-      },
       "dns_queries": {
         "default": "mdi:magnify"
       },
@@ -16,18 +13,21 @@
       "parental_control_blocked": {
         "default": "mdi:human-male-girl"
       },
-      "rules_count": {
-        "default": "mdi:counter"
-      },
       "safe_browsing_blocked": {
         "default": "mdi:shield-half-full"
       },
       "safe_searches_enforced": {
         "default": "mdi:shield-search"
+      },
+      "average_processing_speed": {
+        "default": "mdi:speedometer"
+      },
+      "rules_count": {
+        "default": "mdi:counter"
       }
     },
     "switch": {
-      "filtering": {
+      "protection": {
         "default": "mdi:shield-check",
         "state": {
           "off": "mdi:shield-off"
@@ -39,13 +39,7 @@
           "off": "mdi:shield-off"
         }
       },
-      "protection": {
-        "default": "mdi:shield-check",
-        "state": {
-          "off": "mdi:shield-off"
-        }
-      },
-      "query_log": {
+      "safe_search": {
         "default": "mdi:shield-check",
         "state": {
           "off": "mdi:shield-off"
@@ -57,7 +51,13 @@
           "off": "mdi:shield-off"
         }
       },
-      "safe_search": {
+      "filtering": {
+        "default": "mdi:shield-check",
+        "state": {
+          "off": "mdi:shield-off"
+        }
+      },
+      "query_log": {
         "default": "mdi:shield-check",
         "state": {
           "off": "mdi:shield-off"
@@ -69,17 +69,17 @@
     "add_url": {
       "service": "mdi:link-plus"
     },
-    "disable_url": {
-      "service": "mdi:link-variant-off"
+    "remove_url": {
+      "service": "mdi:link-off"
     },
     "enable_url": {
       "service": "mdi:link-variant"
     },
+    "disable_url": {
+      "service": "mdi:link-variant-off"
+    },
     "refresh": {
       "service": "mdi:refresh"
-    },
-    "remove_url": {
-      "service": "mdi:link-off"
     }
   }
 }

homeassistant/components/adguard/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_polling",
   "loggers": ["adguardhome"],
-  "requirements": ["adguardhome==0.8.1"]
+  "requirements": ["adguardhome==0.7.0"]
 }

homeassistant/components/adguard/strings.json

@@ -1,38 +1,35 @@
 {
   "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "existing_instance_updated": "Updated existing configuration."
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
-    },
     "step": {
-      "hassio_confirm": {
-        "description": "Do you want to configure Home Assistant to connect to the AdGuard Home provided by the add-on: {addon}?",
-        "title": "AdGuard Home via Home Assistant add-on"
-      },
       "user": {
+        "description": "Set up your AdGuard Home instance to allow monitoring and control.",
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
           "password": "[%key:common::config_flow::data::password%]",
           "port": "[%key:common::config_flow::data::port%]",
-          "ssl": "[%key:common::config_flow::data::ssl%]",
           "username": "[%key:common::config_flow::data::username%]",
+          "ssl": "[%key:common::config_flow::data::ssl%]",
           "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
         },
         "data_description": {
           "host": "The hostname or IP address of the device running your AdGuard Home."
-        },
-        "description": "Set up your AdGuard Home instance to allow monitoring and control."
+        }
+      },
+      "hassio_confirm": {
+        "title": "AdGuard Home via Home Assistant add-on",
+        "description": "Do you want to configure Home Assistant to connect to the AdGuard Home provided by the add-on: {addon}?"
       }
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+    },
+    "abort": {
+      "existing_instance_updated": "Updated existing configuration.",
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
     }
   },
   "entity": {
     "sensor": {
-      "average_processing_speed": {
-        "name": "Average processing speed"
-      },
       "dns_queries": {
         "name": "DNS queries"
       },
@@ -45,91 +42,94 @@
       "parental_control_blocked": {
         "name": "Parental control blocked"
       },
-      "rules_count": {
-        "name": "Rules count"
-      },
       "safe_browsing_blocked": {
         "name": "Safe browsing blocked"
       },
       "safe_searches_enforced": {
         "name": "Safe searches enforced"
+      },
+      "average_processing_speed": {
+        "name": "Average processing speed"
+      },
+      "rules_count": {
+        "name": "Rules count"
       }
     },
     "switch": {
-      "filtering": {
-        "name": "Filtering"
+      "protection": {
+        "name": "Protection"
       },
       "parental": {
         "name": "Parental control"
       },
-      "protection": {
-        "name": "Protection"
-      },
-      "query_log": {
-        "name": "Query log"
+      "safe_search": {
+        "name": "Safe search"
       },
       "safe_browsing": {
         "name": "Safe browsing"
       },
-      "safe_search": {
-        "name": "Safe search"
+      "filtering": {
+        "name": "Filtering"
+      },
+      "query_log": {
+        "name": "Query log"
       }
     }
   },
   "services": {
     "add_url": {
+      "name": "Add URL",
       "description": "Adds a new filter subscription to AdGuard Home.",
       "fields": {
         "name": {
-          "description": "The name of the filter subscription.",
-          "name": "[%key:common::config_flow::data::name%]"
+          "name": "[%key:common::config_flow::data::name%]",
+          "description": "The name of the filter subscription."
         },
         "url": {
-          "description": "The filter URL to subscribe to, containing the filter rules.",
-          "name": "[%key:common::config_flow::data::url%]"
+          "name": "[%key:common::config_flow::data::url%]",
+          "description": "The filter URL to subscribe to, containing the filter rules."
         }
-      },
-      "name": "Add URL"
-    },
-    "disable_url": {
-      "description": "Disables a filter subscription in AdGuard Home.",
-      "fields": {
-        "url": {
-          "description": "The filter subscription URL to disable.",
-          "name": "[%key:common::config_flow::data::url%]"
-        }
-      },
-      "name": "Disable URL"
-    },
-    "enable_url": {
-      "description": "Enables a filter subscription in AdGuard Home.",
-      "fields": {
-        "url": {
-          "description": "The filter subscription URL to enable.",
-          "name": "[%key:common::config_flow::data::url%]"
-        }
-      },
-      "name": "Enable URL"
-    },
-    "refresh": {
-      "description": "Refreshes all filter subscriptions in AdGuard Home.",
-      "fields": {
-        "force": {
-          "description": "Force update (bypasses AdGuard Home throttling), omit for a regular refresh.",
-          "name": "Force"
-        }
-      },
-      "name": "Refresh"
+      }
     },
     "remove_url": {
+      "name": "Remove URL",
       "description": "Removes a filter subscription from AdGuard Home.",
       "fields": {
         "url": {
-          "description": "The filter subscription URL to remove.",
-          "name": "[%key:common::config_flow::data::url%]"
+          "name": "[%key:common::config_flow::data::url%]",
+          "description": "The filter subscription URL to remove."
         }
-      },
-      "name": "Remove URL"
+      }
+    },
+    "enable_url": {
+      "name": "Enable URL",
+      "description": "Enables a filter subscription in AdGuard Home.",
+      "fields": {
+        "url": {
+          "name": "[%key:common::config_flow::data::url%]",
+          "description": "The filter subscription URL to enable."
+        }
+      }
+    },
+    "disable_url": {
+      "name": "Disable URL",
+      "description": "Disables a filter subscription in AdGuard Home.",
+      "fields": {
+        "url": {
+          "name": "[%key:common::config_flow::data::url%]",
+          "description": "The filter subscription URL to disable."
+        }
+      }
+    },
+    "refresh": {
+      "name": "Refresh",
+      "description": "Refreshes all filter subscriptions in AdGuard Home.",
+      "fields": {
+        "force": {
+          "name": "Force",
+          "description": "Force update (bypasses AdGuard Home throttling), omit for a regular refresh."
+        }
+      }
     }
   }
 }

homeassistant/components/adguard/update.py

@@ -1,71 +0,0 @@
-"""AdGuard Home Update platform."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-from typing import Any
-
-from adguardhome import AdGuardHomeError
-
-from homeassistant.components.update import UpdateEntity, UpdateEntityFeature
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import AdGuardConfigEntry, AdGuardData
-from .const import DOMAIN
-from .entity import AdGuardHomeEntity
-
-SCAN_INTERVAL = timedelta(seconds=300)
-PARALLEL_UPDATES = 1
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AdGuardConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up AdGuard Home update entity based on a config entry."""
-    data = entry.runtime_data
-
-    if (await data.client.update.update_available()).disabled:
-        return
-
-    async_add_entities([AdGuardHomeUpdate(data, entry)], True)
-
-
-class AdGuardHomeUpdate(AdGuardHomeEntity, UpdateEntity):
-    """Defines an AdGuard Home update."""
-
-    _attr_supported_features = UpdateEntityFeature.INSTALL
-    _attr_name = None
-
-    def __init__(
-        self,
-        data: AdGuardData,
-        entry: AdGuardConfigEntry,
-    ) -> None:
-        """Initialize AdGuard Home update."""
-        super().__init__(data, entry)
-
-        self._attr_unique_id = "_".join(
-            [DOMAIN, self.adguard.host, str(self.adguard.port), "update"]
-        )
-
-    async def _adguard_update(self) -> None:
-        """Update AdGuard Home entity."""
-        value = await self.adguard.update.update_available()
-        self._attr_installed_version = self.data.version
-        self._attr_latest_version = value.new_version
-        self._attr_release_summary = value.announcement
-        self._attr_release_url = value.announcement_url
-
-    async def async_install(
-        self, version: str | None, backup: bool, **kwargs: Any
-    ) -> None:
-        """Install latest update."""
-        try:
-            await self.adguard.update.begin_update()
-        except AdGuardHomeError as err:
-            raise HomeAssistantError(f"Failed to install update: {err}") from err
-        self.hass.config_entries.async_schedule_reload(self._entry.entry_id)

homeassistant/components/ads/strings.json

@@ -1,22 +1,22 @@
 {
   "services": {
     "write_data_by_name": {
+      "name": "Write data by name",
       "description": "Write a value to the connected ADS device.",
       "fields": {
-        "adstype": {
-          "description": "The data type of the variable to write to.",
-          "name": "ADS type"
-        },
         "adsvar": {
-          "description": "The name of the variable to write to.",
-          "name": "ADS variable"
+          "name": "ADS variable",
+          "description": "The name of the variable to write to."
+        },
+        "adstype": {
+          "name": "ADS type",
+          "description": "The data type of the variable to write to."
         },
         "value": {
-          "description": "The value to write to the variable.",
-          "name": "Value"
+          "name": "Value",
+          "description": "The value to write to the variable."
         }
-      },
-      "name": "Write data by name"
+      }
     }
   }
 }

homeassistant/components/advantage_air/manifest.json

@@ -4,7 +4,6 @@
   "codeowners": ["@Bre77"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/advantage_air",
-  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["advantage_air"],
   "requirements": ["advantage-air==0.4.4"]