Modify query as template in SQL integration

.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

@@ -6,17 +6,14 @@ core: &core
   - homeassistant/helpers/**
   - homeassistant/package_constraints.txt
   - homeassistant/util/**
-  - mypy.ini
   - pyproject.toml
   - requirements.txt
   - setup.cfg
 
 # 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/**
   - homeassistant/components/binary_sensor/**
   - homeassistant/components/button/**
   - homeassistant/components/calendar/**
@@ -59,13 +56,11 @@ 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/**
   - homeassistant/components/automation/**
   - homeassistant/components/backup/**
-  - homeassistant/components/blueprint/**
   - homeassistant/components/bluetooth/**
   - homeassistant/components/cloud/**
   - homeassistant/components/config/**
@@ -82,7 +77,6 @@ components: &components
   - homeassistant/components/group/**
   - homeassistant/components/hassio/**
   - homeassistant/components/homeassistant/**
-  - homeassistant/components/homeassistant_hardware/**
   - homeassistant/components/http/**
   - homeassistant/components/image/**
   - homeassistant/components/input_boolean/**
@@ -91,7 +85,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/**
@@ -116,7 +109,6 @@ components: &components
   - homeassistant/components/tag/**
   - homeassistant/components/template/**
   - homeassistant/components/timer/**
-  - homeassistant/components/trace/**
   - homeassistant/components/usb/**
   - homeassistant/components/webhook/**
   - homeassistant/components/websocket_api/**
@@ -132,13 +124,9 @@ tests: &tests
   - tests/*.py
   - tests/auth/**
   - tests/backports/**
-  - tests/components/conftest.py
-  - tests/components/diagnostics/**
   - tests/components/history/**
-  - tests/components/light/common.py
   - tests/components/logbook/**
   - tests/components/recorder/**
-  - tests/components/repairs/**
   - tests/components/sensor/**
   - tests/hassfest/**
   - tests/helpers/**

.devcontainer/devcontainer.json

@@ -2,37 +2,30 @@
   "name": "Home Assistant Dev",
   "context": "..",
   "dockerFile": "../Dockerfile.dev",
-  "postCreateCommand": "git config --global --add safe.directory ${containerWorkspaceFolder} && script/setup",
+  "postCreateCommand": "script/setup",
   "postStartCommand": "script/bootstrap",
   "containerEnv": {
     "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": {}
   },
   // Port 5683 udp is used by Shelly integration
   "appPort": ["8123:8123", "5683:5683/udp"],
-  "runArgs": [
-    "-e",
-    "GIT_EDITOR=code --wait",
-    "--security-opt",
-    "label=disable"
-  ],
+  "runArgs": ["-e", "GIT_EDITOR=code --wait"],
   "customizations": {
     "vscode": {
       "extensions": [
         "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 +33,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,
@@ -62,16 +53,7 @@
         ],
         "[python]": {
           "editor.defaultFormatter": "charliermarsh.ruff"
-        },
-        "[json][jsonc][yaml]": {
-          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        },
-        "json.schemas": [
-          {
-            "fileMatch": ["homeassistant/components/*/manifest.json"],
-            "url": "${containerWorkspaceFolder}/script/json_schemas/manifest_schema.json"
-          }
-        ]
+        }
       }
     }
   }

.dockerignore

@@ -7,15 +7,13 @@ docs
 # Development
 .devcontainer
 .vscode
-.tool-versions
 
 # Test related files
 tests
 
 # Other virtualization methods
 venv
-.venv
 .vagrant
 
 # Temporary files
-**/__pycache__
+**/__pycache__

.gitattributes

@@ -11,14 +11,3 @@
 *.pcm binary
 
 Dockerfile.dev linguist-language=Dockerfile
-
-# Generated files
-CODEOWNERS linguist-generated=true
-Dockerfile linguist-generated=true
-homeassistant/generated/*.py linguist-generated=true
-mypy.ini linguist-generated=true
-requirements.txt linguist-generated=true
-requirements_all.txt linguist-generated=true
-requirements_test_all.txt linguist-generated=true
-requirements_test_pre_commit.txt linguist-generated=true
-script/hassfest/docker/Dockerfile linguist-generated=true

.github/FUNDING.yml

@@ -1 +1,2 @@
-custom: https://www.openhomefoundation.org
+custom: https://www.nabucasa.com
+github: balloob

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -6,9 +6,9 @@ body:
       value: |
         This issue form is for reporting bugs only!
 
-        If you have a feature or enhancement request, please [request them here instead][fr].
+        If you have a feature or enhancement request, please use the [feature request][fr] section of our [Community Forum][fr].
 
-        [fr]: https://github.com/orgs/home-assistant/discussions
+        [fr]: https://community.home-assistant.io/c/feature-requests
   - type: textarea
     validations:
       required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -10,8 +10,8 @@ contact_links:
     url: https://www.home-assistant.io/help
     about: We use GitHub for tracking bugs, check our website for resources on getting help.
   - name: Feature Request
-    url: https://github.com/orgs/home-assistant/discussions
-    about: Please use this link to request new features or enhancements to existing features.
+    url: https://community.home-assistant.io/c/feature-requests
+    about: Please use our Community Forum for making feature requests.
   - name: I'm unsure where to go
     url: https://www.home-assistant.io/join-chat
     about: If you are unsure where to go, then joining our chat is recommended; Just ask!

.github/ISSUE_TEMPLATE/task.yml

@@ -1,53 +0,0 @@
-name: Task
-description: For staff only - Create a task
-type: Task
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## ⚠️ RESTRICTED ACCESS
-
-        **This form is restricted to Open Home Foundation staff, authorized contributors, and integration code owners only.**
-
-        If you are a community member wanting to contribute, please:
-        - For bug reports: Use the [bug report form](https://github.com/home-assistant/core/issues/new?template=bug_report.yml)
-        - For feature requests: Submit to [Feature Requests](https://github.com/orgs/home-assistant/discussions)
-
-        ---
-
-        ### For authorized contributors
-
-        Use this form to create tasks for development work, improvements, or other actionable items that need to be tracked.
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: |
-        Provide a clear and detailed description of the task that needs to be accomplished.
-
-        Be specific about what needs to be done, why it's important, and any constraints or requirements.
-      placeholder: |
-        Describe the task, including:
-        - What needs to be done
-        - Why this task is needed
-        - Expected outcome
-        - Any constraints or requirements
-    validations:
-      required: true
-  - type: textarea
-    id: additional_context
-    attributes:
-      label: Additional context
-      description: |
-        Any additional information, links, research, or context that would be helpful.
-
-        Include links to related issues, research, prototypes, roadmap opportunities etc.
-      placeholder: |
-        - Roadmap opportunity: [link]
-        - Epic: [link]
-        - Feature request: [link]
-        - Technical design documents: [link]
-        - Prototype/mockup: [link]
-        - Dependencies: [links]
-    validations:
-      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -46,8 +46,6 @@
 - This PR fixes or closes issue: fixes #
 - This PR is related to issue: 
 - Link to documentation pull request: 
-- Link to developer documentation pull request: 
-- Link to frontend pull request: 
 
 ## Checklist
 <!--
@@ -55,12 +53,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 +62,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/dependabot.yml

@@ -6,6 +6,3 @@ updates:
       interval: daily
       time: "06:00"
     open-pull-requests-limit: 10
-    labels:
-      - dependency
-      - github_actions

.github/workflows/builder.yml

@@ -10,13 +10,10 @@ on:
 
 env:
   BUILD_TYPE: core
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.12"
   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@v4.1.7
+        with:
+          fetch-depth: 0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.1.1
         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.3.6
         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@v4.1.7
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
+        uses: dawidd6/action-download-artifact@v6
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -111,10 +105,10 @@ 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@v6
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
-          repo: OHF-Voice/intents-package
+          repo: home-assistant/intents-package
           branch: main
           workflow: nightly.yaml
           workflow_conclusion: success
@@ -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.1.1
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
@@ -132,7 +126,7 @@ jobs:
         env:
           UV_PRERELEASE: allow
         run: |
-          python3 -m pip install "$(grep '^uv' < requirements.txt)"
+          python3 -m pip install "$(grep '^uv' < requirements_test.txt)"
           uv pip install packaging tomli
           uv pip install .
           python3 script/version_bump.py nightly --set-nightly-version "${{ needs.init.outputs.version }}"
@@ -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@v4.1.8
         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.3.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@2024.08.2
         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@v4.1.7
 
       - 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.3.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@2024.08.2
         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@v4.1.7
 
       - 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 }}
@@ -350,139 +316,149 @@ jobs:
       packages: write
       id-token: write
     strategy:
-      fail-fast: false
       matrix:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
-      - *install_cosign
+      - name: Checkout the repository
+        uses: actions/checkout@v4.1.7
+
+      - name: Install Cosign
+        uses: sigstore/cosign-installer@v3.6.0
+        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.3.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.3.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
     environment: ${{ needs.init.outputs.channel }}
     needs: ["init", "build_base"]
     runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
     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@v4.1.7
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.1.1
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 
       - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        uses: actions/download-artifact@v4.1.8
         with:
           name: translations
 
@@ -496,63 +472,13 @@ jobs:
         run: |
           # Remove dist, build, and homeassistant.egg-info
           # when build locally for testing!
-          pip install build
+          pip install twine build
           python -m build
 
-      - name: Upload package to PyPI
-        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
-        with:
-          skip-existing: true
+      - name: Upload package
+        shell: bash
+        run: |
+          export TWINE_USERNAME="__token__"
+          export TWINE_PASSWORD="${{ secrets.TWINE_TOKEN }}"
 
-  hassfest-image:
-    name: Build and test hassfest image
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-      attestations: write
-      id-token: write
-    needs: ["init"]
-    if: github.repository_owner == 'home-assistant'
-    env:
-      HASSFEST_IMAGE_NAME: ghcr.io/home-assistant/hassfest
-      HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build Docker image
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
-        with:
-          context: . # So action will not pull the repository again
-          file: ./script/hassfest/docker/Dockerfile
-          load: true
-          tags: ${{ env.HASSFEST_IMAGE_TAG }}
-
-      - name: Run hassfest against core
-        run: docker run --rm -v ${{ github.workspace }}:/github/workspace ${{ env.HASSFEST_IMAGE_TAG }} --core-path=/github/workspace
-
-      - name: Push Docker image
-        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        id: push
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
-        with:
-          context: . # So action will not pull the repository again
-          file: ./script/hassfest/docker/Dockerfile
-          push: true
-          tags: ${{ env.HASSFEST_IMAGE_TAG }},${{ env.HASSFEST_IMAGE_NAME }}:latest
-
-      - name: Generate artifact attestation
-        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@00014ed6ed5efc5b1ab7f7f34a39eb55d41aa4f8 # v3.1.0
-        with:
-          subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
-          subject-digest: ${{ steps.push.outputs.digest }}
-          push-to-registry: true
+          twine upload dist/* --skip-existing

.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@v4.1.7
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/init@v3.26.4
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
+        uses: github/codeql-action/analyze@v3.26.4
         with:
           category: "/language:python"

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

@@ -1,385 +0,0 @@
-name: Auto-detect duplicate issues
-
-# yamllint disable-line rule:truthy
-on:
-  issues:
-    types: [labeled]
-
-permissions:
-  issues: write
-  models: read
-
-jobs:
-  detect-duplicates:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check if integration label was added and extract details
-        id: extract
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
-        with:
-          script: |
-            // Debug: Log the event payload
-            console.log('Event name:', context.eventName);
-            console.log('Event action:', context.payload.action);
-            console.log('Event payload keys:', Object.keys(context.payload));
-
-            // Check the specific label that was added
-            const addedLabel = context.payload.label;
-            if (!addedLabel) {
-              console.log('No label found in labeled event payload');
-              core.setOutput('should_continue', 'false');
-              return;
-            }
-
-            console.log(`Label added: ${addedLabel.name}`);
-
-            if (!addedLabel.name.startsWith('integration:')) {
-              console.log('Added label is not an integration label, skipping duplicate detection');
-              core.setOutput('should_continue', 'false');
-              return;
-            }
-
-            console.log(`Integration label added: ${addedLabel.name}`);
-
-            let currentIssue;
-            let integrationLabels = [];
-
-            try {
-              const issue = await github.rest.issues.get({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.issue.number
-              });
-
-              currentIssue = issue.data;
-
-              // Check if potential-duplicate label already exists
-              const hasPotentialDuplicateLabel = currentIssue.labels
-                .some(label => label.name === 'potential-duplicate');
-
-              if (hasPotentialDuplicateLabel) {
-                console.log('Issue already has potential-duplicate label, skipping duplicate detection');
-                core.setOutput('should_continue', 'false');
-                return;
-              }
-
-              integrationLabels = currentIssue.labels
-                .filter(label => label.name.startsWith('integration:'))
-                .map(label => label.name);
-            } catch (error) {
-              core.error(`Failed to fetch issue #${context.payload.issue.number}:`, error.message);
-              core.setOutput('should_continue', 'false');
-              return;
-            }
-
-            // Check if we've already posted a duplicate detection comment recently
-            let comments;
-            try {
-              comments = await github.rest.issues.listComments({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.issue.number,
-                per_page: 10
-              });
-            } catch (error) {
-              core.error('Failed to fetch comments:', error.message);
-              // Continue anyway, worst case we might post a duplicate comment
-              comments = { data: [] };
-            }
-
-            // Check if we've already posted a duplicate detection comment
-            const recentDuplicateComment = comments.data.find(comment =>
-              comment.user && comment.user.login === 'github-actions[bot]' &&
-              comment.body.includes('<!-- workflow: detect-duplicate-issues -->')
-            );
-
-            if (recentDuplicateComment) {
-              console.log('Already posted duplicate detection comment, skipping');
-              core.setOutput('should_continue', 'false');
-              return;
-            }
-
-            core.setOutput('should_continue', 'true');
-            core.setOutput('current_number', currentIssue.number);
-            core.setOutput('current_title', currentIssue.title);
-            core.setOutput('current_body', currentIssue.body);
-            core.setOutput('current_url', currentIssue.html_url);
-            core.setOutput('integration_labels', JSON.stringify(integrationLabels));
-
-            console.log(`Current issue: #${currentIssue.number}`);
-            console.log(`Integration labels: ${integrationLabels.join(', ')}`);
-
-      - name: Fetch similar issues
-        id: fetch_similar
-        if: steps.extract.outputs.should_continue == 'true'
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
-        env:
-          INTEGRATION_LABELS: ${{ steps.extract.outputs.integration_labels }}
-          CURRENT_NUMBER: ${{ steps.extract.outputs.current_number }}
-        with:
-          script: |
-            const integrationLabels = JSON.parse(process.env.INTEGRATION_LABELS);
-            const currentNumber = parseInt(process.env.CURRENT_NUMBER);
-
-            if (integrationLabels.length === 0) {
-              console.log('No integration labels found, skipping duplicate detection');
-              core.setOutput('has_similar', 'false');
-              return;
-            }
-
-            // Use GitHub search API to find issues with matching integration labels
-            console.log(`Searching for issues with integration labels: ${integrationLabels.join(', ')}`);
-
-            // Build search query for issues with any of the current integration labels
-            const labelQueries = integrationLabels.map(label => `label:"${label}"`);
-
-            // Calculate date 6 months ago
-            const sixMonthsAgo = new Date();
-            sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
-            const dateFilter = `created:>=${sixMonthsAgo.toISOString().split('T')[0]}`;
-
-            let searchQuery;
-
-            if (labelQueries.length === 1) {
-              searchQuery = `repo:${context.repo.owner}/${context.repo.repo} is:issue ${labelQueries[0]} ${dateFilter}`;
-            } else {
-              searchQuery = `repo:${context.repo.owner}/${context.repo.repo} is:issue (${labelQueries.join(' OR ')}) ${dateFilter}`;
-            }
-
-            console.log(`Search query: ${searchQuery}`);
-
-            let result;
-            try {
-              result = await github.rest.search.issuesAndPullRequests({
-                q: searchQuery,
-                per_page: 15,
-                sort: 'updated',
-                order: 'desc'
-              });
-            } catch (error) {
-              core.error('Failed to search for similar issues:', error.message);
-              if (error.status === 403 && error.message.includes('rate limit')) {
-                core.error('GitHub API rate limit exceeded');
-              }
-              core.setOutput('has_similar', 'false');
-              return;
-            }
-
-            // Filter out the current issue, pull requests, and newer issues (higher numbers)
-            const similarIssues = result.data.items
-              .filter(item =>
-                item.number !== currentNumber &&
-                !item.pull_request &&
-                item.number < currentNumber // Only include older issues (lower numbers)
-              )
-              .map(item => ({
-                number: item.number,
-                title: item.title,
-                body: item.body,
-                url: item.html_url,
-                state: item.state,
-                createdAt: item.created_at,
-                updatedAt: item.updated_at,
-                comments: item.comments,
-                labels: item.labels.map(l => l.name)
-              }));
-
-            console.log(`Found ${similarIssues.length} issues with matching integration labels`);
-            console.log('Raw similar issues:', JSON.stringify(similarIssues.slice(0, 3), null, 2));
-
-            if (similarIssues.length === 0) {
-              console.log('No similar issues found, setting has_similar to false');
-              core.setOutput('has_similar', 'false');
-              return;
-            }
-
-            console.log('Similar issues found, setting has_similar to true');
-            core.setOutput('has_similar', 'true');
-
-            // Clean the issue data to prevent JSON parsing issues
-            const cleanedIssues = similarIssues.slice(0, 15).map(item => {
-              // Handle body with improved truncation and null handling
-              let cleanBody = '';
-              if (item.body && typeof item.body === 'string') {
-                // Remove control characters
-                const cleaned = item.body.replace(/[\u0000-\u001F\u007F-\u009F]/g, '');
-                // Truncate to 1000 characters and add ellipsis if needed
-                cleanBody = cleaned.length > 1000
-                  ? cleaned.substring(0, 1000) + '...'
-                  : cleaned;
-              }
-
-              return {
-                number: item.number,
-                title: item.title.replace(/[\u0000-\u001F\u007F-\u009F]/g, ''), // Remove control characters
-                body: cleanBody,
-                url: item.url,
-                state: item.state,
-                createdAt: item.createdAt,
-                updatedAt: item.updatedAt,
-                comments: item.comments,
-                labels: item.labels
-              };
-            });
-
-            console.log(`Cleaned issues count: ${cleanedIssues.length}`);
-            console.log('First cleaned issue:', JSON.stringify(cleanedIssues[0], null, 2));
-
-            core.setOutput('similar_issues', JSON.stringify(cleanedIssues));
-
-      - 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
-        with:
-          model: openai/gpt-4o
-          system-prompt: |
-            You are a Home Assistant issue duplicate detector. Your task is to identify TRUE DUPLICATES - issues that report the EXACT SAME problem, not just similar or related issues.
-
-            CRITICAL: An issue is ONLY a duplicate if:
-            - It describes the SAME problem with the SAME root cause
-            - Issues about the same integration but different problems are NOT duplicates
-            - Issues with similar symptoms but different causes are NOT duplicates
-
-            Important considerations:
-            - Open issues are more relevant than closed ones for duplicate detection
-            - Recently updated issues may indicate ongoing work or discussion
-            - Issues with more comments are generally more relevant and active
-            - Older closed issues might be resolved differently than newer approaches
-            - Consider the time between issues - very old issues may have different contexts
-
-            Rules:
-            1. ONLY mark as duplicate if the issues describe IDENTICAL problems
-            2. Look for issues that report the same problem or request the same functionality
-            3. Different error messages = NOT a duplicate (even if same integration)
-            4. For CLOSED issues, only mark as duplicate if they describe the EXACT same problem
-            5. For OPEN issues, use a lower threshold (90%+ similarity)
-            6. Prioritize issues with higher comment counts as they indicate more activity/relevance
-            7. When in doubt, do NOT mark as duplicate
-            8. Return ONLY a JSON array of issue numbers that are duplicates
-            9. If no duplicates are found, return an empty array: []
-            10. Maximum 5 potential duplicates, prioritize open issues with comments
-            11. Consider the age of issues - prefer recent duplicates over very old ones
-
-            Example response format:
-            [1234, 5678, 9012]
-
-          prompt: |
-            Current issue (just created):
-            Title: ${{ steps.extract.outputs.current_title }}
-            Body: ${{ steps.extract.outputs.current_body }}
-
-            Other issues to compare against (each includes state, creation date, last update, and comment count):
-            ${{ steps.fetch_similar.outputs.similar_issues }}
-
-            Analyze these issues and identify which ones describe IDENTICAL problems and thus are duplicates of the current issue. When sorting them, consider their state (open/closed), how recently they were updated, and their comment count (higher = more relevant).
-
-          max-tokens: 100
-
-      - 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
-        env:
-          AI_RESPONSE: ${{ steps.ai_detection.outputs.response }}
-          SIMILAR_ISSUES: ${{ steps.fetch_similar.outputs.similar_issues }}
-        with:
-          script: |
-            const aiResponse = process.env.AI_RESPONSE;
-
-            console.log('Raw AI response:', JSON.stringify(aiResponse));
-
-            let duplicateNumbers = [];
-            try {
-              // Clean the response of any potential control characters
-              const cleanResponse = aiResponse.trim().replace(/[\u0000-\u001F\u007F-\u009F]/g, '');
-              console.log('Cleaned AI response:', cleanResponse);
-
-              duplicateNumbers = JSON.parse(cleanResponse);
-
-              // Ensure it's an array and contains only numbers
-              if (!Array.isArray(duplicateNumbers)) {
-                console.log('AI response is not an array, trying to extract numbers');
-                const numberMatches = cleanResponse.match(/\d+/g);
-                duplicateNumbers = numberMatches ? numberMatches.map(n => parseInt(n)) : [];
-              }
-
-              // Filter to only valid numbers
-              duplicateNumbers = duplicateNumbers.filter(n => typeof n === 'number' && !isNaN(n));
-
-            } catch (error) {
-              console.log('Failed to parse AI response as JSON:', error.message);
-              console.log('Raw response:', aiResponse);
-
-              // Fallback: try to extract numbers from the response
-              const numberMatches = aiResponse.match(/\d+/g);
-              duplicateNumbers = numberMatches ? numberMatches.map(n => parseInt(n)) : [];
-              console.log('Extracted numbers as fallback:', duplicateNumbers);
-            }
-
-            if (!Array.isArray(duplicateNumbers) || duplicateNumbers.length === 0) {
-              console.log('No duplicates detected by AI');
-              return;
-            }
-
-            console.log(`AI detected ${duplicateNumbers.length} potential duplicates: ${duplicateNumbers.join(', ')}`);
-
-            // Get details of detected duplicates
-            const similarIssues = JSON.parse(process.env.SIMILAR_ISSUES);
-            const duplicates = similarIssues.filter(issue => duplicateNumbers.includes(issue.number));
-
-            if (duplicates.length === 0) {
-              console.log('No matching issues found for detected numbers');
-              return;
-            }
-
-            // Create comment with duplicate detection results
-            const duplicateLinks = duplicates.map(issue => `- [#${issue.number}: ${issue.title}](${issue.url})`).join('\n');
-
-            const commentBody = [
-              '<!-- workflow: detect-duplicate-issues -->',
-              '### 🔍 **Potential duplicate detection**',
-              '',
-              'I\'ve analyzed similar issues and found the following potential duplicates:',
-              '',
-              duplicateLinks,
-              '',
-              '**What to do next:**',
-              '1. Please review these issues to see if they match your issue',
-              '2. If you find an existing issue that covers your problem:',
-              '   - Consider closing this issue',
-              '   - Add your findings or 👍 on the existing issue instead',
-              '3. If your issue is different or adds new aspects, please clarify how it differs',
-              '',
-              'This helps keep our issues organized and ensures similar issues are consolidated for better visibility.',
-              '',
-              '*This message was generated automatically by our duplicate detection system.*'
-            ].join('\n');
-
-            try {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.issue.number,
-                body: commentBody
-              });
-
-              console.log(`Posted duplicate detection comment with ${duplicates.length} potential duplicates`);
-
-              // Add the potential-duplicate label
-              await github.rest.issues.addLabels({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.issue.number,
-                labels: ['potential-duplicate']
-              });
-
-              console.log('Added potential-duplicate label to the issue');
-            } catch (error) {
-              core.error('Failed to post duplicate detection comment or add label:', error.message);
-              if (error.status === 403) {
-                core.error('Permission denied or rate limit exceeded');
-              }
-              // Don't throw - we've done the analysis, just couldn't post the result
-            }

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

@@ -1,193 +0,0 @@
-name: Auto-detect non-English issues
-
-# yamllint disable-line rule:truthy
-on:
-  issues:
-    types: [opened]
-
-permissions:
-  issues: write
-  models: read
-
-jobs:
-  detect-language:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Check issue language
-        id: detect_language
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
-        env:
-          ISSUE_NUMBER: ${{ github.event.issue.number }}
-          ISSUE_TITLE: ${{ github.event.issue.title }}
-          ISSUE_BODY: ${{ github.event.issue.body }}
-          ISSUE_USER_TYPE: ${{ github.event.issue.user.type }}
-        with:
-          script: |
-            // Get the issue details from environment variables
-            const issueNumber = process.env.ISSUE_NUMBER;
-            const issueTitle = process.env.ISSUE_TITLE || '';
-            const issueBody = process.env.ISSUE_BODY || '';
-            const userType = process.env.ISSUE_USER_TYPE;
-
-            // Skip language detection for bot users
-            if (userType === 'Bot') {
-              console.log('Skipping language detection for bot user');
-              core.setOutput('should_continue', 'false');
-              return;
-            }
-
-            console.log(`Checking language for issue #${issueNumber}`);
-            console.log(`Title: ${issueTitle}`);
-
-            // Combine title and body for language detection
-            const fullText = `${issueTitle}\n\n${issueBody}`;
-
-            // Check if the text is too short to reliably detect language
-            if (fullText.trim().length < 20) {
-              console.log('Text too short for reliable language detection');
-              core.setOutput('should_continue', 'false'); // Skip processing for very short text
-              return;
-            }
-
-            core.setOutput('issue_number', issueNumber);
-            core.setOutput('issue_text', fullText);
-            core.setOutput('should_continue', 'true');
-
-      - 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
-        with:
-          model: openai/gpt-4o-mini
-          system-prompt: |
-            You are a language detection system. Your task is to determine if the provided text is written in English or another language.
-
-            Rules:
-            1. Analyze the text and determine the primary language of the USER'S DESCRIPTION only
-            2. IGNORE markdown headers (lines starting with #, ##, ###, etc.) as these are from issue templates, not user input
-            3. IGNORE all code blocks (text between ``` or ` markers) as they may contain system-generated error messages in other languages
-            4. IGNORE error messages, logs, and system output even if not in code blocks - these often appear in the user's system language
-            5. Consider technical terms, code snippets, URLs, and file paths as neutral (they don't indicate non-English)
-            6. Focus ONLY on the actual sentences and descriptions written by the user explaining their issue
-            7. If the user's explanation/description is in English but includes non-English error messages or logs, consider it ENGLISH
-            8. Return ONLY a JSON object with two fields:
-               - "is_english": boolean (true if the user's description is primarily in English, false otherwise)
-               - "detected_language": string (the name of the detected language, e.g., "English", "Spanish", "Chinese", etc.)
-            9. Be lenient - if the user's explanation is in English with non-English system output, it's still English
-            10. Common programming terms, error messages, and technical jargon should not be considered as non-English
-            11. If you cannot reliably determine the language, set detected_language to "undefined"
-
-            Example response:
-            {"is_english": false, "detected_language": "Spanish"}
-
-          prompt: |
-            Please analyze the following issue text and determine if it is written in English:
-
-            ${{ steps.detect_language.outputs.issue_text }}
-
-          max-tokens: 50
-
-      - name: Process non-English issues
-        if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
-        env:
-          AI_RESPONSE: ${{ steps.ai_language_detection.outputs.response }}
-          ISSUE_NUMBER: ${{ steps.detect_language.outputs.issue_number }}
-        with:
-          script: |
-            const issueNumber = parseInt(process.env.ISSUE_NUMBER);
-            const aiResponse = process.env.AI_RESPONSE;
-
-            console.log('AI language detection response:', aiResponse);
-
-            let languageResult;
-            try {
-              languageResult = JSON.parse(aiResponse.trim());
-
-              // Validate the response structure
-              if (!languageResult || typeof languageResult.is_english !== 'boolean') {
-                throw new Error('Invalid response structure');
-              }
-            } catch (error) {
-              core.error(`Failed to parse AI response: ${error.message}`);
-              console.log('Raw AI response:', aiResponse);
-
-              // Log more details for debugging
-              core.warning('Defaulting to English due to parsing error');
-
-              // Default to English if we can't parse the response
-              return;
-            }
-
-            if (languageResult.is_english) {
-              console.log('Issue is in English, no action needed');
-              return;
-            }
-
-            // If language is undefined or not detected, skip processing
-            if (!languageResult.detected_language || languageResult.detected_language === 'undefined') {
-              console.log('Language could not be determined, skipping processing');
-              return;
-            }
-
-            console.log(`Issue detected as non-English: ${languageResult.detected_language}`);
-
-            // Post comment explaining the language requirement
-            const commentBody = [
-              '<!-- workflow: detect-non-english-issues -->',
-              '### 🌐 Non-English issue detected',
-              '',
-              `This issue appears to be written in **${languageResult.detected_language}** rather than English.`,
-              '',
-              'The Home Assistant project uses English as the primary language for issues to ensure that everyone in our international community can participate and help resolve issues. This allows any of our thousands of contributors to jump in and provide assistance.',
-              '',
-              '**What to do:**',
-              '1. Re-create the issue using the English language',
-              '2. If you need help with translation, consider using:',
-              '   - Translation tools like Google Translate',
-              '   - AI assistants like ChatGPT or Claude',
-              '',
-              'This helps our community provide the best possible support and ensures your issue gets the attention it deserves from our global contributor base.',
-              '',
-              'Thank you for your understanding! 🙏'
-            ].join('\n');
-
-            try {
-              // Add comment
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber,
-                body: commentBody
-              });
-
-              console.log('Posted language requirement comment');
-
-              // Add non-english label
-              await github.rest.issues.addLabels({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber,
-                labels: ['non-english']
-              });
-
-              console.log('Added non-english label');
-
-              // Close the issue
-              await github.rest.issues.update({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: issueNumber,
-                state: 'closed',
-                state_reason: 'not_planned'
-              });
-
-              console.log('Closed the issue');
-
-            } catch (error) {
-              core.error('Failed to process non-English issue:', error.message);
-              if (error.status === 403) {
-                core.error('Permission denied or rate limit exceeded');
-              }
-            }

.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

@@ -1,84 +0,0 @@
-name: Restrict task creation
-
-# yamllint disable-line rule:truthy
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  check-authorization:
-    runs-on: ubuntu-latest
-    # Only run if this is a Task issue type (from the issue form)
-    if: github.event.issue.type.name == 'Task'
-    steps:
-      - name: Check if user is authorized
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
-        with:
-          script: |
-            const issueAuthor = context.payload.issue.user.login;
-
-            // First check if user is an organization member
-            try {
-              await github.rest.orgs.checkMembershipForUser({
-                org: 'home-assistant',
-                username: issueAuthor
-              });
-              console.log(`✅ ${issueAuthor} is an organization member`);
-              return; // Authorized, no need to check further
-            } catch (error) {
-              console.log(`ℹ️ ${issueAuthor} is not an organization member, checking codeowners...`);
-            }
-
-            // If not an org member, check if they're a codeowner
-            try {
-              // Fetch CODEOWNERS file from the repository
-              const { data: codeownersFile } = await github.rest.repos.getContent({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                path: 'CODEOWNERS',
-                ref: 'dev'
-              });
-
-              // Decode the content (it's base64 encoded)
-              const codeownersContent = Buffer.from(codeownersFile.content, 'base64').toString('utf-8');
-
-              // Check if the issue author is mentioned in CODEOWNERS
-              // GitHub usernames in CODEOWNERS are prefixed with @
-              if (codeownersContent.includes(`@${issueAuthor}`)) {
-                console.log(`✅ ${issueAuthor} is a integration code owner`);
-                return; // Authorized
-              }
-            } catch (error) {
-              console.error('Error checking CODEOWNERS:', error);
-            }
-
-            // If we reach here, user is not authorized
-            console.log(`❌ ${issueAuthor} is not authorized to create Task issues`);
-
-            // Close the issue with a comment
-            await github.rest.issues.createComment({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              body: `Hi @${issueAuthor}, thank you for your contribution!\n\n` +
-                    `Task issues are restricted to Open Home Foundation staff, authorized contributors, and integration code owners.\n\n` +
-                    `If you would like to:\n` +
-                    `- Report a bug: Please use the [bug report form](https://github.com/home-assistant/core/issues/new?template=bug_report.yml)\n` +
-                    `- Request a feature: Please submit to [Feature Requests](https://github.com/orgs/home-assistant/discussions)\n\n` +
-                    `If you believe you should have access to create Task issues, please contact the maintainers.`
-            });
-
-            await github.rest.issues.update({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              state: 'closed'
-            });
-
-            // Add a label to indicate this was auto-closed
-            await github.rest.issues.addLabels({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: context.issue.number,
-              labels: ['auto-closed']
-            });

.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.0.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.0.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.0.0
         with:
           repo-token: ${{ steps.token.outputs.token }}
           only-labels: "needs-more-information"

.github/workflows/translations.yml

@@ -10,7 +10,7 @@ on:
       - "**strings.json"
 
 env:
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.12"
 
 jobs:
   upload:
@@ -19,10 +19,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v4.1.7
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.1.1
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
 

.github/workflows/wheels.yml

@@ -17,7 +17,7 @@ on:
       - "script/gen_requirements_all.py"
 
 env:
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.12"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name}}
@@ -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@v4.1.7
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
-        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        uses: actions/setup-python@v5.1.1
         with:
           python-version: ${{ env.DEFAULT_PYTHON }}
           check-latest: true
@@ -45,9 +46,13 @@ jobs:
           python -m venv venv
           . venv/bin/activate
           python --version
-          pip install "$(grep '^uv' < requirements.txt)"
+          pip install "$(grep '^uv' < requirements_test.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
@@ -59,8 +64,11 @@ jobs:
       - name: Write env-file
         run: |
           (
+            echo "GRPC_BUILD_WITH_BORING_SSL_ASM=false"
             echo "GRPC_PYTHON_BUILD_SYSTEM_OPENSSL=true"
             echo "GRPC_PYTHON_BUILD_WITH_CYTHON=true"
+            echo "GRPC_PYTHON_DISABLE_LIBC_COMPATIBILITY=true"
+            echo "GRPC_PYTHON_LDFLAGS=-lpthread -Wl,-wrap,memcpy -static-libgcc"
 
             # Fix out of memory issues with rust
             echo "CARGO_NET_GIT_FETCH_WITH_CLI=true"
@@ -74,15 +82,14 @@ jobs:
           ) > .env_file
 
       - name: Upload env_file
-        uses: &actions-upload-artifact actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@v4.3.6
         with:
           name: env_file
           path: ./.env_file
-          include-hidden-files: true
           overwrite: true
 
       - name: Upload requirements_diff
-        uses: *actions-upload-artifact
+        uses: actions/upload-artifact@v4.3.6
         with:
           name: requirements_diff
           path: ./requirements_diff.txt
@@ -94,7 +101,7 @@ jobs:
           python -m script.gen_requirements_all ci
 
       - name: Upload requirements_all_wheels
-        uses: *actions-upload-artifact
+        uses: actions/upload-artifact@v4.3.6
         with:
           name: requirements_all_wheels
           path: ./requirements_all_wheels_*.txt
@@ -103,48 +110,36 @@ 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: ["cp312"]
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
     steps:
-      - *checkout
+      - name: Checkout the repository
+        uses: actions/checkout@v4.1.7
 
-      - &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@v4.1.8
         with:
           name: env_file
 
-      - &download-requirements-diff
-        name: Download requirements_diff
-        uses: *actions-download-artifact
+      - name: Download requirements_diff
+        uses: actions/download-artifact@v4.1.8
         with:
           name: requirements_diff
 
-      - name: Adjust build env
-        run: |
-          # Don't build wheels for uv as uv requires a greater version of rust as currently available on alpine
-          sed -i "/uv/d" requirements.txt
-          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@2024.07.1
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
           arch: ${{ matrix.arch }}
           wheels-key: ${{ secrets.WHEELS_KEY }}
           env-file: true
-          apk: "libffi-dev;openssl-dev;yaml-dev;nasm;zlib-ng-dev"
-          skip-binary: aiohttp;multidict;propcache;yarl;SQLAlchemy
+          apk: "libffi-dev;openssl-dev;yaml-dev;nasm"
+          skip-binary: aiohttp
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"
           requirements: "requirements.txt"
@@ -153,40 +148,113 @@ 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: ["cp312"]
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
     steps:
-      - *checkout
+      - name: Checkout the repository
+        uses: actions/checkout@v4.1.7
 
-      - *download-env-file
+      - name: Download env_file
+        uses: actions/download-artifact@v4.1.8
+        with:
+          name: env_file
 
-      - *download-requirements-diff
+      - name: Download requirements_diff
+        uses: actions/download-artifact@v4.1.8
+        with:
+          name: requirements_diff
 
       - name: Download requirements_all_wheels
-        uses: *actions-download-artifact
+        uses: actions/download-artifact@v4.1.8
         with:
           name: requirements_all_wheels
 
+      - name: Split requirements all
+        run: |
+          # We split requirements all into multiple files.
+          # This is to prevent the build from running out of memory when
+          # resolving packages on 32-bits systems (like armhf, armv7).
+
+          split -l $(expr $(expr $(cat requirements_all.txt | wc -l) + 1) / 3) requirements_all_wheels_${{ matrix.arch }}.txt requirements_all.txt
+
+      - name: Create requirements for cython<3
+        run: |
+          # Some dependencies still require 'cython<3'
+          # and don't yet use isolated build environments.
+          # Build these first.
+          # grpcio: https://github.com/grpc/grpc/issues/33918
+          # pydantic: https://github.com/pydantic/pydantic/issues/7689
+
+          touch requirements_old-cython.txt
+          cat homeassistant/package_constraints.txt | grep 'grpcio==' >> requirements_old-cython.txt
+          cat homeassistant/package_constraints.txt | grep 'pydantic==' >> requirements_old-cython.txt
+
       - 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
-          sed -i "/uv/d" requirements.txt
-          sed -i "/uv/d" requirements_diff.txt
 
-      - name: Build wheels
-        uses: *home-assistant-wheels
+      - name: Build wheels (old cython)
+        uses: home-assistant/wheels@2024.07.1
         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"
-          skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
+          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"
+          skip-binary: aiohttp;charset-normalizer;grpcio;SQLAlchemy;protobuf;pydantic;pymicro-vad
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"
-          requirements: "requirements_all.txt"
+          requirements: "requirements_old-cython.txt"
+          pip: "'cython<3'"
+
+      - name: Build wheels (part 1)
+        uses: home-assistant/wheels@2024.07.1
+        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;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"
+          skip-binary: aiohttp;charset-normalizer;grpcio;SQLAlchemy;protobuf;pydantic;pymicro-vad
+          constraints: "homeassistant/package_constraints.txt"
+          requirements-diff: "requirements_diff.txt"
+          requirements: "requirements_all.txtaa"
+
+      - name: Build wheels (part 2)
+        uses: home-assistant/wheels@2024.07.1
+        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;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"
+          skip-binary: aiohttp;charset-normalizer;grpcio;SQLAlchemy;protobuf;pydantic;pymicro-vad
+          constraints: "homeassistant/package_constraints.txt"
+          requirements-diff: "requirements_diff.txt"
+          requirements: "requirements_all.txtab"
+
+      - name: Build wheels (part 3)
+        uses: home-assistant/wheels@2024.07.1
+        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;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"
+          skip-binary: aiohttp;charset-normalizer;grpcio;SQLAlchemy;protobuf;pydantic;pymicro-vad
+          constraints: "homeassistant/package_constraints.txt"
+          requirements-diff: "requirements_diff.txt"
+          requirements: "requirements_all.txtac"

.gitignore

@@ -69,7 +69,6 @@ test-reports/
 test-results.xml
 test-output.xml
 pytest-*.txt
-junit.xml
 
 # Translations
 *.mo
@@ -79,7 +78,7 @@ junit.xml
 .project
 .pydevproject
 
-.tool-versions
+.python-version
 
 # emacs auto backups
 *~
@@ -92,7 +91,6 @@ pip-selfcheck.json
 venv
 .venv
 Pipfile*
-uv.lock
 share/*
 /Scripts/
 
@@ -112,7 +110,6 @@ virtualization/vagrant/config
 !.vscode/cSpell.json
 !.vscode/extensions.json
 !.vscode/tasks.json
-!.vscode/settings.default.jsonc
 .env
 
 # Windows Explorer
@@ -138,9 +135,4 @@ tmp_cache
 .ropeproject
 
 # Will be created from script/split_tests.py
-pytest_buckets.txt
-
-# AI tooling
-.claude/settings.local.json
-.serena/
-
+pytest_buckets.txt

.pre-commit-config.yaml

@@ -1,24 +1,24 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.13
+    rev: v0.6.2
     hooks:
-      - id: ruff-check
+      - id: ruff
         args:
           - --fix
       - id: ruff-format
         files: ^((homeassistant|pylint|script|tests)/.+)?[^/]+\.(py|pyi)$
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.1
+    rev: v2.3.0
     hooks:
       - id: codespell
         args:
-          - --ignore-words-list=aiport,astroid,checkin,currenty,hass,iif,incomfort,lookin,nam,NotIn
+          - --ignore-words-list=astroid,checkin,currenty,hass,iif,incomfort,lookin,nam,NotIn
           - --skip="./.*,*.csv,*.json,*.ambr"
           - --quiet-level=2
         exclude_types: [csv, json, html]
         exclude: ^tests/fixtures/|homeassistant/generated/|tests/components/.*/snapshots/
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v6.0.0
+    rev: v4.4.0
     hooks:
       - id: check-executables-have-shebangs
         stages: [manual]
@@ -30,23 +30,20 @@ repos:
           - --branch=master
           - --branch=rc
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.37.1
+    rev: v1.35.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:
@@ -64,14 +61,13 @@ repos:
         name: mypy
         entry: script/run-in-env.sh mypy
         language: script
-        require_serial: true
         types_or: [python, pyi]
+        require_serial: true
         files: ^(homeassistant|pylint)/.+\.(py|pyi)$
       - id: pylint
         name: pylint
-        entry: script/run-in-env.sh pylint --ignore-missing-annotations=y
+        entry: script/run-in-env.sh pylint -j 0 --ignore-missing-annotations=y
         language: script
-        require_serial: true
         types_or: [python, pyi]
         files: ^(homeassistant|tests)/.+\.(py|pyi)$
       - id: gen_requirements_all
@@ -87,14 +83,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/brands/.*\.json|homeassistant/.+/services\.yaml|script/hassfest/(?!metadata|mypy_config).+\.py|requirements_test.txt)$
       - id: hassfest-metadata
         name: hassfest-metadata
-        entry: script/run-in-env.sh python3 -m script.hassfest -p metadata,docker
+        entry: script/run-in-env.sh python3 -m script.hassfest -p metadata
         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)$
       - 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

@@ -41,7 +41,6 @@ homeassistant.util.unit_system
 # --- Add components below this line ---
 homeassistant.components
 homeassistant.components.abode.*
-homeassistant.components.acaia.*
 homeassistant.components.accuweather.*
 homeassistant.components.acer_projector.*
 homeassistant.components.acmeda.*
@@ -53,7 +52,6 @@ homeassistant.components.air_quality.*
 homeassistant.components.airgradient.*
 homeassistant.components.airly.*
 homeassistant.components.airnow.*
-homeassistant.components.airos.*
 homeassistant.components.airq.*
 homeassistant.components.airthings.*
 homeassistant.components.airthings_ble.*
@@ -66,9 +64,7 @@ homeassistant.components.aladdin_connect.*
 homeassistant.components.alarm_control_panel.*
 homeassistant.components.alert.*
 homeassistant.components.alexa.*
-homeassistant.components.alexa_devices.*
 homeassistant.components.alpha_vantage.*
-homeassistant.components.altruist.*
 homeassistant.components.amazon_polly.*
 homeassistant.components.amberelectric.*
 homeassistant.components.ambient_network.*
@@ -99,15 +95,12 @@ homeassistant.components.aruba.*
 homeassistant.components.arwn.*
 homeassistant.components.aseko_pool_live.*
 homeassistant.components.assist_pipeline.*
-homeassistant.components.assist_satellite.*
 homeassistant.components.asuswrt.*
 homeassistant.components.autarco.*
 homeassistant.components.auth.*
 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.*
@@ -117,21 +110,18 @@ homeassistant.components.bitcoin.*
 homeassistant.components.blockchain.*
 homeassistant.components.blue_current.*
 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.*
 homeassistant.components.braviatv.*
-homeassistant.components.bring.*
 homeassistant.components.brother.*
 homeassistant.components.browser.*
 homeassistant.components.bryant_evolution.*
 homeassistant.components.bthome.*
 homeassistant.components.button.*
 homeassistant.components.calendar.*
-homeassistant.components.cambridge_audio.*
 homeassistant.components.camera.*
 homeassistant.components.canary.*
 homeassistant.components.cert_expiry.*
@@ -140,19 +130,15 @@ homeassistant.components.clicksend.*
 homeassistant.components.climate.*
 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.*
 homeassistant.components.counter.*
 homeassistant.components.cover.*
 homeassistant.components.cpuspeed.*
 homeassistant.components.crownstone.*
 homeassistant.components.date.*
 homeassistant.components.datetime.*
-homeassistant.components.deako.*
 homeassistant.components.deconz.*
 homeassistant.components.default_config.*
 homeassistant.components.demo.*
@@ -170,7 +156,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.*
@@ -179,15 +164,14 @@ homeassistant.components.easyenergy.*
 homeassistant.components.ecovacs.*
 homeassistant.components.ecowitt.*
 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 +187,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,38 +204,27 @@ 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.*
 homeassistant.components.google.*
 homeassistant.components.google_assistant_sdk.*
-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.*
 homeassistant.components.group.*
 homeassistant.components.guardian.*
-homeassistant.components.habitica.*
 homeassistant.components.hardkernel.*
 homeassistant.components.hardware.*
-homeassistant.components.heos.*
 homeassistant.components.here_travel_time.*
 homeassistant.components.history.*
 homeassistant.components.history_stats.*
 homeassistant.components.holiday.*
-homeassistant.components.home_connect.*
 homeassistant.components.homeassistant.*
 homeassistant.components.homeassistant_alerts.*
 homeassistant.components.homeassistant_green.*
 homeassistant.components.homeassistant_hardware.*
 homeassistant.components.homeassistant_sky_connect.*
 homeassistant.components.homeassistant_yellow.*
-homeassistant.components.homee.*
 homeassistant.components.homekit.*
 homeassistant.components.homekit_controller
 homeassistant.components.homekit_controller.alarm_control_panel
@@ -278,9 +250,6 @@ homeassistant.components.image_processing.*
 homeassistant.components.image_upload.*
 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.*
@@ -291,7 +260,6 @@ homeassistant.components.ios.*
 homeassistant.components.iotty.*
 homeassistant.components.ipp.*
 homeassistant.components.iqvia.*
-homeassistant.components.iron_os.*
 homeassistant.components.islamic_prayer_times.*
 homeassistant.components.isy994.*
 homeassistant.components.jellyfin.*
@@ -301,7 +269,6 @@ homeassistant.components.kaleidescape.*
 homeassistant.components.knocki.*
 homeassistant.components.knx.*
 homeassistant.components.kraken.*
-homeassistant.components.kulersky.*
 homeassistant.components.lacrosse.*
 homeassistant.components.lacrosse_view.*
 homeassistant.components.lamarzocco.*
@@ -311,12 +278,10 @@ homeassistant.components.lawn_mower.*
 homeassistant.components.lcn.*
 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.*
+homeassistant.components.linear_garage_door.*
 homeassistant.components.linkplay.*
 homeassistant.components.litejet.*
 homeassistant.components.litterrobot.*
@@ -327,42 +292,35 @@ homeassistant.components.logbook.*
 homeassistant.components.logger.*
 homeassistant.components.london_underground.*
 homeassistant.components.lookin.*
-homeassistant.components.lovelace.*
 homeassistant.components.luftdaten.*
-homeassistant.components.lunatone.*
 homeassistant.components.madvr.*
+homeassistant.components.mailbox.*
 homeassistant.components.manual.*
+homeassistant.components.map.*
 homeassistant.components.mastodon.*
 homeassistant.components.matrix.*
 homeassistant.components.matter.*
-homeassistant.components.mcp.*
-homeassistant.components.mcp_server.*
-homeassistant.components.mealie.*
 homeassistant.components.media_extractor.*
 homeassistant.components.media_player.*
 homeassistant.components.media_source.*
 homeassistant.components.met_eireann.*
 homeassistant.components.metoffice.*
-homeassistant.components.miele.*
 homeassistant.components.mikrotik.*
 homeassistant.components.min_max.*
 homeassistant.components.minecraft_server.*
 homeassistant.components.mjpeg.*
 homeassistant.components.modbus.*
 homeassistant.components.modem_callerid.*
-homeassistant.components.mold_indicator.*
 homeassistant.components.monzo.*
 homeassistant.components.moon.*
 homeassistant.components.mopeka.*
 homeassistant.components.motionmount.*
 homeassistant.components.mqtt.*
-homeassistant.components.music_assistant.*
 homeassistant.components.my.*
 homeassistant.components.mysensors.*
 homeassistant.components.myuplink.*
 homeassistant.components.nam.*
 homeassistant.components.nanoleaf.*
-homeassistant.components.nasweb.*
 homeassistant.components.neato.*
 homeassistant.components.nest.*
 homeassistant.components.netatmo.*
@@ -372,44 +330,26 @@ homeassistant.components.nfandroidtv.*
 homeassistant.components.nightscout.*
 homeassistant.components.nissan_leaf.*
 homeassistant.components.no_ip.*
-homeassistant.components.nordpool.*
 homeassistant.components.notify.*
 homeassistant.components.notion.*
-homeassistant.components.ntfy.*
 homeassistant.components.number.*
 homeassistant.components.nut.*
-homeassistant.components.ohme.*
 homeassistant.components.onboarding.*
 homeassistant.components.oncue.*
-homeassistant.components.onedrive.*
 homeassistant.components.onewire.*
-homeassistant.components.onkyo.*
 homeassistant.components.open_meteo.*
-homeassistant.components.open_router.*
-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.panel_custom.*
-homeassistant.components.paperless_ngx.*
-homeassistant.components.peblar.*
 homeassistant.components.peco.*
-homeassistant.components.pegel_online.*
 homeassistant.components.persistent_notification.*
-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.*
 homeassistant.components.prometheus.*
@@ -419,24 +359,17 @@ homeassistant.components.pure_energie.*
 homeassistant.components.purpleair.*
 homeassistant.components.pushbullet.*
 homeassistant.components.pvoutput.*
-homeassistant.components.pyload.*
-homeassistant.components.python_script.*
-homeassistant.components.qbus.*
 homeassistant.components.qnap_qsw.*
 homeassistant.components.rabbitair.*
 homeassistant.components.radarr.*
-homeassistant.components.radio_browser.*
 homeassistant.components.rainforest_raven.*
 homeassistant.components.rainmachine.*
 homeassistant.components.raspberry_pi.*
 homeassistant.components.rdw.*
 homeassistant.components.recollect_waste.*
 homeassistant.components.recorder.*
-homeassistant.components.remember_the_milk.*
 homeassistant.components.remote.*
-homeassistant.components.remote_calendar.*
 homeassistant.components.renault.*
-homeassistant.components.reolink.*
 homeassistant.components.repairs.*
 homeassistant.components.rest.*
 homeassistant.components.rest_command.*
@@ -448,17 +381,14 @@ 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.rtsp_to_webrtc.*
 homeassistant.components.ruuvi_gateway.*
 homeassistant.components.ruuvitag_ble.*
 homeassistant.components.samsungtv.*
-homeassistant.components.saunum.*
 homeassistant.components.scene.*
 homeassistant.components.schedule.*
-homeassistant.components.schlage.*
 homeassistant.components.scrape.*
 homeassistant.components.script.*
 homeassistant.components.search.*
@@ -466,12 +396,8 @@ homeassistant.components.select.*
 homeassistant.components.sensibo.*
 homeassistant.components.sensirion_ble.*
 homeassistant.components.sensor.*
-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.*
 homeassistant.components.simplepush.*
@@ -479,24 +405,17 @@ homeassistant.components.simplisafe.*
 homeassistant.components.siren.*
 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.*
 homeassistant.components.snooz.*
-homeassistant.components.solarlog.*
 homeassistant.components.sonarr.*
 homeassistant.components.speedtestdotnet.*
-homeassistant.components.spotify.*
 homeassistant.components.sql.*
-homeassistant.components.squeezebox.*
 homeassistant.components.ssdp.*
 homeassistant.components.starlink.*
 homeassistant.components.statistics.*
 homeassistant.components.steamist.*
-homeassistant.components.stookwijzer.*
+homeassistant.components.stookalert.*
 homeassistant.components.stream.*
 homeassistant.components.streamlabswater.*
 homeassistant.components.stt.*
@@ -504,7 +423,6 @@ homeassistant.components.suez_water.*
 homeassistant.components.sun.*
 homeassistant.components.surepetcare.*
 homeassistant.components.switch.*
-homeassistant.components.switch_as_x.*
 homeassistant.components.switchbee.*
 homeassistant.components.switchbot_cloud.*
 homeassistant.components.switcher_kis.*
@@ -516,12 +434,10 @@ homeassistant.components.tag.*
 homeassistant.components.tailscale.*
 homeassistant.components.tailwind.*
 homeassistant.components.tami4.*
-homeassistant.components.tankerkoenig.*
 homeassistant.components.tautulli.*
 homeassistant.components.tcp.*
 homeassistant.components.technove.*
 homeassistant.components.tedee.*
-homeassistant.components.telegram_bot.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*
 homeassistant.components.threshold.*
@@ -552,24 +468,18 @@ homeassistant.components.unifiprotect.*
 homeassistant.components.upcloud.*
 homeassistant.components.update.*
 homeassistant.components.uptime.*
-homeassistant.components.uptime_kuma.*
 homeassistant.components.uptimerobot.*
 homeassistant.components.usb.*
-homeassistant.components.uvc.*
 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.*
 homeassistant.components.wake_on_lan.*
 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.*
@@ -580,9 +490,7 @@ homeassistant.components.whois.*
 homeassistant.components.withings.*
 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/launch.json

@@ -38,17 +38,10 @@
       "module": "pytest",
       "justMyCode": false,
       "args": [
+        "--timeout=10",
         "--picked"
       ],
     },
-    {
-      "name": "Home Assistant: Debug Current Test File",
-      "type": "debugpy",
-      "request": "launch",
-      "module": "pytest",
-      "console": "integratedTerminal",
-      "args": ["-vv", "${file}"]
-    },
     {
       // Debug by attaching to local Home Assistant server using Remote Python Debugger.
       // See https://www.home-assistant.io/integrations/debugpy/
@@ -84,4 +77,4 @@
       ]
     }
   ]
-}
+}

.vscode/settings.default.json

@@ -0,0 +1,10 @@
+{
+  // Please keep this file 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"
+}

.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

@@ -4,7 +4,7 @@
     {
       "label": "Run Home Assistant Core",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m homeassistant -c ./config",
+      "command": "hass -c ./config",
       "group": "test",
       "presentation": {
         "reveal": "always",
@@ -16,7 +16,7 @@
     {
       "label": "Pytest",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m pytest --timeout=10 tests",
+      "command": "python3 -m pytest --timeout=10 tests",
       "dependsOn": ["Install all Test Requirements"],
       "group": {
         "kind": "test",
@@ -31,7 +31,7 @@
     {
       "label": "Pytest (changed tests only)",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m pytest --timeout=10 --picked",
+      "command": "python3 -m pytest --timeout=10 --picked",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -45,21 +45,7 @@
     {
       "label": "Ruff",
       "type": "shell",
-      "command": "prek run ruff-check --all-files",
-      "group": {
-        "kind": "test",
-        "isDefault": true
-      },
-      "presentation": {
-        "reveal": "always",
-        "panel": "new"
-      },
-      "problemMatcher": []
-    },
-    {
-      "label": "Prek",
-      "type": "shell",
-      "command": "prek run --show-diff-on-failure",
+      "command": "pre-commit run ruff --all-files",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -89,23 +75,7 @@
       "label": "Code Coverage",
       "detail": "Generate code coverage report for a given integration.",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m pytest ./tests/components/${input:integrationName}/ --cov=homeassistant.components.${input:integrationName} --cov-report term-missing --durations-min=1 --durations=0 --numprocesses=auto",
-      "dependsOn": ["Compile English translations"],
-      "group": {
-        "kind": "test",
-        "isDefault": true
-      },
-      "presentation": {
-        "reveal": "always",
-        "panel": "new"
-      },
-      "problemMatcher": []
-    },
-    {
-      "label": "Update syrupy snapshots",
-      "detail": "Update syrupy snapshots for a given integration.",
-      "type": "shell",
-      "command": "${command:python.interpreterPath} -m pytest ./tests/components/${input:integrationName} --snapshot-update",
+      "command": "python3 -m pytest ./tests/components/${input:integrationName}/ --cov=homeassistant.components.${input:integrationName} --cov-report term-missing --durations-min=1 --durations=0 --numprocesses=auto",
       "dependsOn": ["Compile English translations"],
       "group": {
         "kind": "test",
@@ -120,7 +90,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
@@ -148,7 +118,7 @@
     {
       "label": "Install all Test Requirements",
       "type": "shell",
-      "command": "uv pip install -r requirements.txt -r requirements_test_all.txt",
+      "command": "uv pip install -r requirements_test_all.txt",
       "group": {
         "kind": "build",
         "isDefault": true
@@ -163,7 +133,7 @@
       "label": "Compile English translations",
       "detail": "In order to test changes to translation files, the translation strings must be compiled into Home Assistant's translation directories.",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m script.translations develop --all",
+      "command": "python3 -m script.translations develop --all",
       "group": {
         "kind": "build",
         "isDefault": true
@@ -173,7 +143,7 @@
       "label": "Run scaffold",
       "detail": "Add new functionality to a integration using a scaffold.",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m script.scaffold ${input:scaffoldName} --integration ${input:integrationName}",
+      "command": "python3 -m script.scaffold ${input:scaffoldName} --integration ${input:integrationName}",
       "group": {
         "kind": "build",
         "isDefault": true
@@ -183,7 +153,7 @@
       "label": "Create new integration",
       "detail": "Use the scaffold to create a new integration.",
       "type": "shell",
-      "command": "${command:python.interpreterPath} -m script.scaffold integration",
+      "command": "python3 -m script.scaffold integration",
       "group": {
         "kind": "build",
         "isDefault": true

AGENTS.md

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

CLAUDE.md

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

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,15 @@
 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
+    UV_SYSTEM_PYTHON=true
 
-# Home Assistant S6-Overlay
-COPY rootfs /
+ARG QEMU_CPU
 
-# Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc@sha256:f394f6329f5389a4c9a7fc54b09fdec9621bbb78bf7a672b973440bbdfb02241 /usr/local/bin/go2rtc /bin/go2rtc
-
-RUN \
-    # Verify go2rtc can be executed
-    go2rtc --version \
-    # Install uv
-    && pip3 install uv==0.9.17
+# Install uv
+RUN pip3 install uv==0.2.27
 
 WORKDIR /usr/src
 
@@ -47,9 +29,15 @@ RUN \
     if ls homeassistant/home_assistant_*.whl 1> /dev/null 2>&1; then \
         uv pip install homeassistant/home_assistant_*.whl; \
     fi \
-    && uv pip install \
-        --no-build \
-        -r homeassistant/requirements_all.txt
+    && if [ "${BUILD_ARCH}" = "i386" ]; then \
+        linux32 uv pip install \
+            --no-build \
+            -r homeassistant/requirements_all.txt; \
+    else \
+        uv pip install \
+            --no-build \
+            -r homeassistant/requirements_all.txt; \
+    fi
 
 ## Setup Home Assistant Core
 COPY . homeassistant/
@@ -59,4 +47,7 @@ RUN \
     && python3 -m compileall \
         homeassistant/homeassistant
 
+# Home Assistant S6-Overlay
+COPY rootfs /
+
 WORKDIR /config

Dockerfile.dev

@@ -1,9 +1,18 @@
-FROM mcr.microsoft.com/vscode/devcontainers/base:debian
+FROM mcr.microsoft.com/devcontainers/python:1-3.12
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]
 
+# Uninstall pre-installed formatting and linting tools
+# They would conflict with our pinned versions
 RUN \
-    apt-get update \
+    pipx uninstall pydocstyle \
+    && pipx uninstall pycodestyle \
+    && pipx uninstall mypy \
+    && pipx uninstall pylint
+
+RUN \
+    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 +22,7 @@ RUN \
         libavcodec-dev \
         libavdevice-dev \
         libavutil-dev \
+        libgammu-dev \
         libswscale-dev \
         libswresample-dev \
         libavfilter-dev \
@@ -22,37 +32,33 @@ RUN \
         libxml2 \
         git \
         cmake \
-        autoconf \
     && apt-get clean \
     && rm -rf /var/lib/apt/lists/*
 
-# Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc:latest /usr/local/bin/go2rtc /bin/go2rtc
+# Install uv
+RUN pip3 install uv
 
 WORKDIR /usr/src
 
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+# Setup hass-release
+RUN git clone --depth 1 https://github.com/home-assistant/hass-release \
+    && uv pip install --system -e hass-release/
 
 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"
 
-# Setup hass-release
-RUN git clone --depth 1 https://github.com/home-assistant/hass-release ~/hass-release \
-    && uv pip install -e ~/hass-release/
+WORKDIR /tmp
 
 # 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
 
 # Set the default shell to bash instead of sh
-ENV SHELL=/bin/bash
+ENV SHELL /bin/bash

README.rst

@@ -7,6 +7,8 @@ Check out `home-assistant.io <https://home-assistant.io>`__ for `a
 demo <https://demo.home-assistant.io>`__, `installation instructions <https://home-assistant.io/getting-started/>`__,
 `tutorials <https://home-assistant.io/getting-started/automation/>`__ and `documentation <https://home-assistant.io/docs/>`__.
 
+This is a project of the `Open Home Foundation <https://www.openhomefoundation.org/>`__.
+
 |screenshot-states|
 
 Featured integrations
@@ -20,14 +22,9 @@ components <https://developers.home-assistant.io/docs/creating_component_index/>
 If you run into issues while using Home Assistant or during development
 of a component, check the `Home Assistant help section <https://home-assistant.io/help/>`__ of our website for further help and information.
 
-|ohf-logo|
-
 .. |Chat Status| image:: https://img.shields.io/discord/330944238910963714.svg
    :target: https://www.home-assistant.io/join-chat/
 .. |screenshot-states| image:: https://raw.githubusercontent.com/home-assistant/core/dev/.github/assets/screenshot-states.png
    :target: https://demo.home-assistant.io
 .. |screenshot-integrations| image:: https://raw.githubusercontent.com/home-assistant/core/dev/.github/assets/screenshot-integrations.png
    :target: https://home-assistant.io/integrations/
-.. |ohf-logo| image:: https://www.openhomefoundation.org/badges/home-assistant.png
-   :alt: Home Assistant - A project from the Open Home Foundation
-   :target: https://www.openhomefoundation.org/

build.yaml

@@ -0,0 +1,22 @@
+image: ghcr.io/home-assistant/{arch}-homeassistant
+build_from:
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2024.06.1
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2024.06.1
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2024.06.1
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2024.06.1
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2024.06.1
+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 License 2.0

homeassistant/__main__.py

@@ -9,7 +9,6 @@ import os
 import sys
 import threading
 
-from .backup_restore import restore_backup
 from .const import REQUIRED_PYTHON_VER, RESTART_EXIT_CODE, __version__
 
 FAULT_LOG_FILENAME = "home-assistant.log.fault"
@@ -38,7 +37,8 @@ def validate_python() -> None:
 
 def ensure_config_path(config_dir: str) -> None:
     """Validate the configuration directory."""
-    from . import config as config_util  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    from . import config as config_util
 
     lib_dir = os.path.join(config_dir, "deps")
 
@@ -79,7 +79,8 @@ def ensure_config_path(config_dir: str) -> None:
 
 def get_arguments() -> argparse.Namespace:
     """Get parsed passed in arguments."""
-    from . import config as config_util  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    from . import config as config_util
 
     parser = argparse.ArgumentParser(
         description="Home Assistant: Observe, Control, Automate.",
@@ -175,54 +176,47 @@ def main() -> int:
         validate_os()
 
     if args.script is not None:
-        from . import scripts  # noqa: PLC0415
+        # pylint: disable-next=import-outside-toplevel
+        from . import scripts
 
         return scripts.run(args.script)
 
     config_dir = os.path.abspath(os.path.join(os.getcwd(), args.config))
-    if restore_backup(config_dir):
-        return RESTART_EXIT_CODE
-
     ensure_config_path(config_dir)
 
-    from . import config, runner  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    from . import config, runner
 
-    # 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

@@ -12,6 +12,7 @@ from typing import Any, cast
 
 import jwt
 
+from homeassistant import data_entry_flow
 from homeassistant.core import (
     CALLBACK_TYPE,
     HassJob,
@@ -19,14 +20,13 @@ from homeassistant.core import (
     HomeAssistant,
     callback,
 )
-from homeassistant.data_entry_flow import FlowHandler, FlowManager, FlowResultType
 from homeassistant.helpers.event import async_track_point_in_utc_time
 from homeassistant.util import dt as dt_util
 
 from . import auth_store, jwt_wrapper, models
 from .const import ACCESS_TOKEN_EXPIRATION, GROUP_ID_ADMIN, REFRESH_TOKEN_EXPIRATION
 from .mfa_modules import MultiFactorAuthModule, auth_mfa_module_from_config
-from .models import AuthFlowContext, AuthFlowResult
+from .models import AuthFlowResult
 from .providers import AuthProvider, LoginFlow, auth_provider_from_config
 from .providers.homeassistant import HassAuthProvider
 
@@ -98,7 +98,7 @@ async def auth_manager_from_config(
 
 
 class AuthManagerFlowManager(
-    FlowManager[AuthFlowContext, AuthFlowResult, tuple[str, str]]
+    data_entry_flow.FlowManager[AuthFlowResult, tuple[str, str]]
 ):
     """Manage authentication flows."""
 
@@ -113,9 +113,9 @@ class AuthManagerFlowManager(
         self,
         handler_key: tuple[str, str],
         *,
-        context: AuthFlowContext | None = None,
+        context: dict[str, Any] | None = None,
         data: dict[str, Any] | None = None,
-    ) -> LoginFlow[Any]:
+    ) -> LoginFlow:
         """Create a login flow."""
         auth_provider = self.auth_manager.get_auth_provider(*handler_key)
         if not auth_provider:
@@ -124,17 +124,13 @@ class AuthManagerFlowManager(
 
     async def async_finish_flow(
         self,
-        flow: FlowHandler[AuthFlowContext, AuthFlowResult, tuple[str, str]],
+        flow: data_entry_flow.FlowHandler[AuthFlowResult, tuple[str, str]],
         result: AuthFlowResult,
     ) -> AuthFlowResult:
-        """Return a user as result of login flow.
-
-        This method is called when a flow step returns FlowResultType.ABORT or
-        FlowResultType.CREATE_ENTRY.
-        """
+        """Return a user as result of login flow."""
         flow = cast(LoginFlow, flow)
 
-        if result["type"] != FlowResultType.CREATE_ENTRY:
+        if result["type"] != data_entry_flow.FlowResultType.CREATE_ENTRY:
             return result
 
         # we got final result
@@ -402,8 +398,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/auth_store.py

@@ -120,9 +120,6 @@ class AuthStore:
 
         new_user = models.User(**kwargs)
 
-        while new_user.id in self._users:
-            new_user = models.User(**kwargs)
-
         self._users[new_user.id] = new_user
 
         if credentials is None:
@@ -311,7 +308,7 @@ class AuthStore:
         credentials.data = data
         self._async_schedule_save()
 
-    async def async_load(self) -> None:
+    async def async_load(self) -> None:  # noqa: C901
         """Load the users."""
         if self._loaded:
             raise RuntimeError("Auth storage is already loaded")

homeassistant/auth/jwt_wrapper.py

@@ -18,7 +18,7 @@ from homeassistant.util.json import json_loads
 JWT_TOKEN_CACHE_SIZE = 16
 MAX_TOKEN_SIZE = 8192
 
-_VERIFY_KEYS = ("signature", "exp", "nbf", "iat", "aud", "iss", "sub", "jti")
+_VERIFY_KEYS = ("signature", "exp", "nbf", "iat", "aud", "iss")
 
 _VERIFY_OPTIONS: dict[str, Any] = {f"verify_{key}": True for key in _VERIFY_KEYS} | {
     "require": []

homeassistant/auth/mfa_modules/__init__.py

@@ -71,7 +71,7 @@ class MultiFactorAuthModule:
         """Return a voluptuous schema to define mfa auth module's input."""
         raise NotImplementedError
 
-    async def async_setup_flow(self, user_id: str) -> SetupFlow[Any]:
+    async def async_setup_flow(self, user_id: str) -> SetupFlow:
         """Return a data entry flow handler for setup module.
 
         Mfa module should extend SetupFlow
@@ -95,16 +95,11 @@ class MultiFactorAuthModule:
         raise NotImplementedError
 
 
-class SetupFlow[_MultiFactorAuthModuleT: MultiFactorAuthModule = MultiFactorAuthModule](
-    data_entry_flow.FlowHandler
-):
+class SetupFlow(data_entry_flow.FlowHandler):
     """Handler for the setup flow."""
 
     def __init__(
-        self,
-        auth_module: _MultiFactorAuthModuleT,
-        setup_schema: vol.Schema,
-        user_id: str,
+        self, auth_module: MultiFactorAuthModule, setup_schema: vol.Schema, user_id: str
     ) -> None:
         """Initialize the setup flow."""
         self._auth_module = auth_module

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"
 
@@ -51,28 +52,28 @@ _LOGGER = logging.getLogger(__name__)
 
 def _generate_secret() -> str:
     """Generate a secret."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return str(pyotp.random_base32())
 
 
 def _generate_random() -> int:
     """Generate a 32 digit number."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return int(pyotp.random_base32(length=32, chars=list("1234567890")))
 
 
 def _generate_otp(secret: str, count: int) -> str:
     """Generate one time password."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return str(pyotp.HOTP(secret).at(count))
 
 
 def _verify_otp(secret: str, otp: str, count: int) -> bool:
     """Verify one time password."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return bool(pyotp.HOTP(secret).verify(otp, count))
 
@@ -161,7 +162,7 @@ class NotifyAuthModule(MultiFactorAuthModule):
 
         return sorted(unordered_services)
 
-    async def async_setup_flow(self, user_id: str) -> NotifySetupFlow:
+    async def async_setup_flow(self, user_id: str) -> SetupFlow:
         """Return a data entry flow handler for setup module.
 
         Mfa module should extend SetupFlow
@@ -267,7 +268,7 @@ class NotifyAuthModule(MultiFactorAuthModule):
         await self.hass.services.async_call("notify", notify_service, data)
 
 
-class NotifySetupFlow(SetupFlow[NotifyAuthModule]):
+class NotifySetupFlow(SetupFlow):
     """Handler for the setup flow."""
 
     def __init__(
@@ -279,6 +280,8 @@ class NotifySetupFlow(SetupFlow[NotifyAuthModule]):
     ) -> None:
         """Initialize the setup flow."""
         super().__init__(auth_module, setup_schema, user_id)
+        # to fix typing complaint
+        self._auth_module: NotifyAuthModule = auth_module
         self._available_notify_services = available_notify_services
         self._secret: str | None = None
         self._count: int | None = None
@@ -303,14 +306,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,13 +34,10 @@ 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."""
-    import pyqrcode  # noqa: PLC0415
+    import pyqrcode  # pylint: disable=import-outside-toplevel
 
     qr_code = pyqrcode.create(data)
 
@@ -62,7 +59,7 @@ def _generate_qr_code(data: str) -> str:
 
 def _generate_secret_and_qr_code(username: str) -> tuple[str, str, str]:
     """Generate a secret, url, and QR code."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     ota_secret = pyotp.random_base32()
     url = pyotp.totp.TOTP(ota_secret).provisioning_uri(
@@ -110,14 +107,14 @@ class TotpAuthModule(MultiFactorAuthModule):
 
     def _add_ota_secret(self, user_id: str, secret: str | None = None) -> str:
         """Create a ota_secret for user."""
-        import pyotp  # noqa: PLC0415
+        import pyotp  # pylint: disable=import-outside-toplevel
 
         ota_secret: str = secret or pyotp.random_base32()
 
         self._users[user_id] = ota_secret  # type: ignore[index]
         return ota_secret
 
-    async def async_setup_flow(self, user_id: str) -> TotpSetupFlow:
+    async def async_setup_flow(self, user_id: str) -> SetupFlow:
         """Return a data entry flow handler for setup module.
 
         Mfa module should extend SetupFlow
@@ -166,7 +163,7 @@ class TotpAuthModule(MultiFactorAuthModule):
 
     def _validate_2fa(self, user_id: str, code: str) -> bool:
         """Validate two factor authentication code."""
-        import pyotp  # noqa: PLC0415
+        import pyotp  # pylint: disable=import-outside-toplevel
 
         if (ota_secret := self._users.get(user_id)) is None:  # type: ignore[union-attr]
             # even we cannot find user, we still do verify
@@ -177,19 +174,20 @@ class TotpAuthModule(MultiFactorAuthModule):
         return bool(pyotp.TOTP(ota_secret).verify(code, valid_window=1))
 
 
-class TotpSetupFlow(SetupFlow[TotpAuthModule]):
+class TotpSetupFlow(SetupFlow):
     """Handler for the setup flow."""
 
-    _ota_secret: str
-    _url: str
-    _image: str
-
     def __init__(
         self, auth_module: TotpAuthModule, setup_schema: vol.Schema, user: User
     ) -> None:
         """Initialize the setup flow."""
         super().__init__(auth_module, setup_schema, user.id)
+        # to fix typing complaint
+        self._auth_module: TotpAuthModule = auth_module
         self._user = user
+        self._ota_secret: str = ""
+        self._url: str | None = None
+        self._image: str | None = None
 
     async def async_step_init(
         self, user_input: dict[str, str] | None = None
@@ -199,7 +197,7 @@ class TotpSetupFlow(SetupFlow[TotpAuthModule]):
         Return self.async_show_form(step_id='init') if user_input is None.
         Return self.async_create_entry(data={'result': result}) if finish.
         """
-        import pyotp  # noqa: PLC0415
+        import pyotp  # pylint: disable=import-outside-toplevel
 
         errors: dict[str, str] = {}
 
@@ -216,11 +214,12 @@ class TotpSetupFlow(SetupFlow[TotpAuthModule]):
             errors["base"] = "invalid_code"
 
         else:
+            hass = self._auth_module.hass
             (
                 self._ota_secret,
                 self._url,
                 self._image,
-            ) = await self._auth_module.hass.async_add_executor_job(
+            ) = await hass.async_add_executor_job(
                 _generate_secret_and_qr_code,
                 str(self._user.name),
             )
@@ -232,8 +231,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/models.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from datetime import datetime, timedelta
-from ipaddress import IPv4Address, IPv6Address
+from functools import cached_property
 import secrets
 from typing import Any, NamedTuple
 import uuid
@@ -11,10 +11,9 @@ import uuid
 import attr
 from attr import Attribute
 from attr.setters import validate
-from propcache.api import cached_property
 
 from homeassistant.const import __version__
-from homeassistant.data_entry_flow import FlowContext, FlowResult
+from homeassistant.data_entry_flow import FlowResult
 from homeassistant.util import dt as dt_util
 
 from . import permissions as perm_mdl
@@ -24,19 +23,7 @@ TOKEN_TYPE_NORMAL = "normal"
 TOKEN_TYPE_SYSTEM = "system"
 TOKEN_TYPE_LONG_LIVED_ACCESS_TOKEN = "long_lived_access_token"
 
-
-class AuthFlowContext(FlowContext, total=False):
-    """Typed context dict for auth flow."""
-
-    credential_only: bool
-    ip_address: IPv4Address | IPv6Address
-    redirect_uri: str
-
-
-class AuthFlowResult(FlowResult[AuthFlowContext, tuple[str, str]], total=False):
-    """Typed result dict for auth flow."""
-
-    result: Credentials  # Only present if type is CREATE_ENTRY
+AuthFlowResult = FlowResult[tuple[str, str]]
 
 
 @attr.s(slots=True)

homeassistant/auth/permissions/__init__.py

@@ -17,12 +17,12 @@ POLICY_SCHEMA = vol.Schema({vol.Optional(CAT_ENTITIES): ENTITY_POLICY_SCHEMA})
 
 __all__ = [
     "POLICY_SCHEMA",
-    "AbstractPermissions",
-    "OwnerPermissions",
-    "PermissionLookup",
-    "PolicyPermissions",
-    "PolicyType",
     "merge_policies",
+    "PermissionLookup",
+    "PolicyType",
+    "AbstractPermissions",
+    "PolicyPermissions",
+    "OwnerPermissions",
 ]
 
 

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

@@ -10,10 +10,9 @@ from typing import Any
 import voluptuous as vol
 from voluptuous.humanize import humanize_error
 
-from homeassistant import requirements
+from homeassistant import data_entry_flow, requirements
 from homeassistant.const import CONF_ID, CONF_NAME, CONF_TYPE
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.data_entry_flow import FlowHandler
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.importlib import async_import_module
 from homeassistant.util import dt as dt_util
@@ -22,14 +21,7 @@ from homeassistant.util.hass_dict import HassKey
 
 from ..auth_store import AuthStore
 from ..const import MFA_SESSION_EXPIRATION
-from ..models import (
-    AuthFlowContext,
-    AuthFlowResult,
-    Credentials,
-    RefreshToken,
-    User,
-    UserMeta,
-)
+from ..models import AuthFlowResult, Credentials, RefreshToken, User, UserMeta
 
 _LOGGER = logging.getLogger(__name__)
 DATA_REQS: HassKey[set[str]] = HassKey("auth_prov_reqs_processed")
@@ -105,7 +97,7 @@ class AuthProvider:
 
     # Implement by extending class
 
-    async def async_login_flow(self, context: AuthFlowContext | None) -> LoginFlow[Any]:
+    async def async_login_flow(self, context: dict[str, Any] | None) -> LoginFlow:
         """Return the data flow for logging in with auth provider.
 
         Auth provider should extend LoginFlow and return an instance.
@@ -192,14 +184,12 @@ async def load_auth_provider_module(
     return module
 
 
-class LoginFlow[_AuthProviderT: AuthProvider = AuthProvider](
-    FlowHandler[AuthFlowContext, AuthFlowResult, tuple[str, str]],
-):
+class LoginFlow(data_entry_flow.FlowHandler[AuthFlowResult, tuple[str, str]]):
     """Handler for the login flow."""
 
     _flow_result = AuthFlowResult
 
-    def __init__(self, auth_provider: _AuthProviderT) -> None:
+    def __init__(self, auth_provider: AuthProvider) -> None:
         """Initialize the login flow."""
         self._auth_provider = auth_provider
         self._auth_module_id: str | None = None

homeassistant/auth/providers/command_line.py

@@ -6,14 +6,14 @@ import asyncio
 from collections.abc import Mapping
 import logging
 import os
-from typing import Any
+from typing import Any, cast
 
 import voluptuous as vol
 
 from homeassistant.const import CONF_COMMAND
 from homeassistant.exceptions import HomeAssistantError
 
-from ..models import AuthFlowContext, AuthFlowResult, Credentials, UserMeta
+from ..models import AuthFlowResult, Credentials, UserMeta
 from . import AUTH_PROVIDER_SCHEMA, AUTH_PROVIDERS, AuthProvider, LoginFlow
 
 CONF_ARGS = "args"
@@ -59,9 +59,7 @@ class CommandLineAuthProvider(AuthProvider):
         super().__init__(*args, **kwargs)
         self._user_meta: dict[str, dict[str, Any]] = {}
 
-    async def async_login_flow(
-        self, context: AuthFlowContext | None
-    ) -> CommandLineLoginFlow:
+    async def async_login_flow(self, context: dict[str, Any] | None) -> LoginFlow:
         """Return a flow to login."""
         return CommandLineLoginFlow(self)
 
@@ -135,7 +133,7 @@ class CommandLineAuthProvider(AuthProvider):
         )
 
 
-class CommandLineLoginFlow(LoginFlow[CommandLineAuthProvider]):
+class CommandLineLoginFlow(LoginFlow):
     """Handler for the login flow."""
 
     async def async_step_init(
@@ -147,9 +145,9 @@ class CommandLineLoginFlow(LoginFlow[CommandLineAuthProvider]):
         if user_input is not None:
             user_input["username"] = user_input["username"].strip()
             try:
-                await self._auth_provider.async_validate_login(
-                    user_input["username"], user_input["password"]
-                )
+                await cast(
+                    CommandLineAuthProvider, self._auth_provider
+                ).async_validate_login(user_input["username"], user_input["password"])
             except InvalidAuthError:
                 errors["base"] = "invalid_auth"
 

homeassistant/auth/providers/homeassistant.py

@@ -17,7 +17,7 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.storage import Store
 
-from ..models import AuthFlowContext, AuthFlowResult, Credentials, UserMeta
+from ..models import AuthFlowResult, Credentials, UserMeta
 from . import AUTH_PROVIDER_SCHEMA, AUTH_PROVIDERS, AuthProvider, LoginFlow
 
 STORAGE_VERSION = 1
@@ -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)
@@ -311,7 +305,7 @@ class HassAuthProvider(AuthProvider):
             await data.async_load()
             self.data = data
 
-    async def async_login_flow(self, context: AuthFlowContext | None) -> HassLoginFlow:
+    async def async_login_flow(self, context: dict[str, Any] | None) -> LoginFlow:
         """Return a flow to login."""
         return HassLoginFlow(self)
 
@@ -406,7 +400,7 @@ class HassAuthProvider(AuthProvider):
             pass
 
 
-class HassLoginFlow(LoginFlow[HassAuthProvider]):
+class HassLoginFlow(LoginFlow):
     """Handler for the login flow."""
 
     async def async_step_init(
@@ -417,7 +411,7 @@ class HassLoginFlow(LoginFlow[HassAuthProvider]):
 
         if user_input is not None:
             try:
-                await self._auth_provider.async_validate_login(
+                await cast(HassAuthProvider, self._auth_provider).async_validate_login(
                     user_input["username"], user_input["password"]
                 )
             except InvalidAuth:

homeassistant/auth/providers/insecure_example.py

@@ -4,13 +4,14 @@ from __future__ import annotations
 
 from collections.abc import Mapping
 import hmac
+from typing import Any, cast
 
 import voluptuous as vol
 
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
 
-from ..models import AuthFlowContext, AuthFlowResult, Credentials, UserMeta
+from ..models import AuthFlowResult, Credentials, UserMeta
 from . import AUTH_PROVIDER_SCHEMA, AUTH_PROVIDERS, AuthProvider, LoginFlow
 
 USER_SCHEMA = vol.Schema(
@@ -35,9 +36,7 @@ class InvalidAuthError(HomeAssistantError):
 class ExampleAuthProvider(AuthProvider):
     """Example auth provider based on hardcoded usernames and passwords."""
 
-    async def async_login_flow(
-        self, context: AuthFlowContext | None
-    ) -> ExampleLoginFlow:
+    async def async_login_flow(self, context: dict[str, Any] | None) -> LoginFlow:
         """Return a flow to login."""
         return ExampleLoginFlow(self)
 
@@ -94,7 +93,7 @@ class ExampleAuthProvider(AuthProvider):
         return UserMeta(name=name, is_active=True)
 
 
-class ExampleLoginFlow(LoginFlow[ExampleAuthProvider]):
+class ExampleLoginFlow(LoginFlow):
     """Handler for the login flow."""
 
     async def async_step_init(
@@ -105,7 +104,7 @@ class ExampleLoginFlow(LoginFlow[ExampleAuthProvider]):
 
         if user_input is not None:
             try:
-                self._auth_provider.async_validate_login(
+                cast(ExampleAuthProvider, self._auth_provider).async_validate_login(
                     user_input["username"], user_input["password"]
                 )
             except InvalidAuthError:

homeassistant/auth/providers/trusted_networks.py

@@ -21,17 +21,11 @@ import voluptuous as vol
 
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv
+import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.network import is_cloud_connection
 
 from .. import InvalidAuthError
-from ..models import (
-    AuthFlowContext,
-    AuthFlowResult,
-    Credentials,
-    RefreshToken,
-    UserMeta,
-)
+from ..models import AuthFlowResult, Credentials, RefreshToken, UserMeta
 from . import AUTH_PROVIDER_SCHEMA, AUTH_PROVIDERS, AuthProvider, LoginFlow
 
 type IPAddress = IPv4Address | IPv6Address
@@ -104,9 +98,7 @@ class TrustedNetworksAuthProvider(AuthProvider):
         """Trusted Networks auth provider does not support MFA."""
         return False
 
-    async def async_login_flow(
-        self, context: AuthFlowContext | None
-    ) -> TrustedNetworksLoginFlow:
+    async def async_login_flow(self, context: dict[str, Any] | None) -> LoginFlow:
         """Return a flow to login."""
         assert context is not None
         ip_addr = cast(IPAddress, context.get("ip_address"))
@@ -216,7 +208,7 @@ class TrustedNetworksAuthProvider(AuthProvider):
         self.async_validate_access(ip_address(remote_ip))
 
 
-class TrustedNetworksLoginFlow(LoginFlow[TrustedNetworksAuthProvider]):
+class TrustedNetworksLoginFlow(LoginFlow):
     """Handler for the login flow."""
 
     def __init__(
@@ -237,7 +229,9 @@ class TrustedNetworksLoginFlow(LoginFlow[TrustedNetworksAuthProvider]):
     ) -> AuthFlowResult:
         """Handle the step of the form."""
         try:
-            self._auth_provider.async_validate_access(self._ip_address)
+            cast(
+                TrustedNetworksAuthProvider, self._auth_provider
+            ).async_validate_access(self._ip_address)
 
         except InvalidAuthError:
             return self.async_abort(reason="not_allowed")

homeassistant/backports/enum.py

@@ -0,0 +1,29 @@
+"""Enum backports from standard lib.
+
+This file contained the backport of the StrEnum of Python 3.11.
+
+Since we have dropped support for Python 3.10, we can remove this backport.
+This file is kept for now to avoid breaking custom components that might
+import it.
+"""
+
+from __future__ import annotations
+
+from enum import StrEnum as _StrEnum
+from functools import partial
+
+from homeassistant.helpers.deprecation import (
+    DeprecatedAlias,
+    all_with_deprecated_constants,
+    check_if_deprecated_constant,
+    dir_with_deprecated_constants,
+)
+
+# StrEnum deprecated as of 2024.5 use enum.StrEnum instead.
+_DEPRECATED_StrEnum = DeprecatedAlias(_StrEnum, "enum.StrEnum", "2025.5")
+
+__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
+__dir__ = partial(
+    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
+)
+__all__ = all_with_deprecated_constants(globals())

homeassistant/backports/functools.py

@@ -0,0 +1,30 @@
+"""Functools backports from standard lib.
+
+This file contained the backport of the cached_property implementation of Python 3.12.
+
+Since we have dropped support for Python 3.11, we can remove this backport.
+This file is kept for now to avoid breaking custom components that might
+import it.
+"""
+
+from __future__ import annotations
+
+from functools import cached_property as _cached_property, partial
+
+from homeassistant.helpers.deprecation import (
+    DeprecatedAlias,
+    all_with_deprecated_constants,
+    check_if_deprecated_constant,
+    dir_with_deprecated_constants,
+)
+
+# cached_property deprecated as of 2024.5 use functools.cached_property instead.
+_DEPRECATED_cached_property = DeprecatedAlias(
+    _cached_property, "functools.cached_property", "2025.5"
+)
+
+__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
+__dir__ = partial(
+    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
+)
+__all__ = all_with_deprecated_constants(globals())

homeassistant/backup_restore.py

@@ -1,213 +0,0 @@
-"""Home Assistant module to handle restoring backups."""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass
-import hashlib
-import json
-import logging
-from pathlib import Path
-import shutil
-import sys
-from tempfile import TemporaryDirectory
-
-from awesomeversion import AwesomeVersion
-import securetar
-
-from .const import __version__ as HA_VERSION
-
-RESTORE_BACKUP_FILE = ".HA_RESTORE"
-RESTORE_BACKUP_RESULT_FILE = ".HA_RESTORE_RESULT"
-KEEP_BACKUPS = ("backups",)
-KEEP_DATABASE = (
-    "home-assistant_v2.db",
-    "home-assistant_v2.db-wal",
-)
-
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass
-class RestoreBackupFileContent:
-    """Definition for restore backup file content."""
-
-    backup_file_path: Path
-    password: str | None
-    remove_after_restore: bool
-    restore_database: bool
-    restore_homeassistant: bool
-
-
-def password_to_key(password: str) -> bytes:
-    """Generate a AES Key from password.
-
-    Matches the implementation in supervisor.backups.utils.password_to_key.
-    """
-    key: bytes = password.encode()
-    for _ in range(100):
-        key = hashlib.sha256(key).digest()
-    return key[:16]
-
-
-def restore_backup_file_content(config_dir: Path) -> RestoreBackupFileContent | None:
-    """Return the contents of the restore backup file."""
-    instruction_path = config_dir.joinpath(RESTORE_BACKUP_FILE)
-    try:
-        instruction_content = json.loads(instruction_path.read_text(encoding="utf-8"))
-        return RestoreBackupFileContent(
-            backup_file_path=Path(instruction_content["path"]),
-            password=instruction_content["password"],
-            remove_after_restore=instruction_content["remove_after_restore"],
-            restore_database=instruction_content["restore_database"],
-            restore_homeassistant=instruction_content["restore_homeassistant"],
-        )
-    except FileNotFoundError:
-        return None
-    except (KeyError, json.JSONDecodeError) as err:
-        _write_restore_result_file(config_dir, False, err)
-        return None
-    finally:
-        # Always remove the backup instruction file to prevent a boot loop
-        instruction_path.unlink(missing_ok=True)
-
-
-def _clear_configuration_directory(config_dir: Path, keep: Iterable[str]) -> None:
-    """Delete all files and directories in the config directory except entries in the keep list."""
-    keep_paths = [config_dir.joinpath(path) for path in keep]
-    entries_to_remove = sorted(
-        entry for entry in config_dir.iterdir() if entry not in keep_paths
-    )
-
-    for entry in entries_to_remove:
-        entrypath = config_dir.joinpath(entry)
-
-        if entrypath.is_file():
-            entrypath.unlink()
-        elif entrypath.is_dir():
-            shutil.rmtree(entrypath)
-
-
-def _extract_backup(
-    config_dir: Path,
-    restore_content: RestoreBackupFileContent,
-) -> None:
-    """Extract the backup file to the config directory."""
-    with (
-        TemporaryDirectory() as tempdir,
-        securetar.SecureTarFile(
-            restore_content.backup_file_path,
-            gzip=False,
-            mode="r",
-        ) as ostf,
-    ):
-        ostf.extractall(
-            path=Path(tempdir, "extracted"),
-            members=securetar.secure_path(ostf),
-            filter="fully_trusted",
-        )
-        backup_meta_file = Path(tempdir, "extracted", "backup.json")
-        backup_meta = json.loads(backup_meta_file.read_text(encoding="utf8"))
-
-        if (
-            backup_meta_version := AwesomeVersion(
-                backup_meta["homeassistant"]["version"]
-            )
-        ) > HA_VERSION:
-            raise ValueError(
-                f"You need at least Home Assistant version {backup_meta_version} to restore this backup"
-            )
-
-        with securetar.SecureTarFile(
-            Path(
-                tempdir,
-                "extracted",
-                f"homeassistant.tar{'.gz' if backup_meta['compressed'] else ''}",
-            ),
-            gzip=backup_meta["compressed"],
-            key=password_to_key(restore_content.password)
-            if restore_content.password is not None
-            else None,
-            mode="r",
-        ) as istf:
-            istf.extractall(
-                path=Path(tempdir, "homeassistant"),
-                members=securetar.secure_path(istf),
-                filter="fully_trusted",
-            )
-            if restore_content.restore_homeassistant:
-                keep = list(KEEP_BACKUPS)
-                if not restore_content.restore_database:
-                    keep.extend(KEEP_DATABASE)
-                _clear_configuration_directory(config_dir, keep)
-                shutil.copytree(
-                    Path(tempdir, "homeassistant", "data"),
-                    config_dir,
-                    dirs_exist_ok=True,
-                    ignore=shutil.ignore_patterns(*(keep)),
-                    ignore_dangling_symlinks=True,
-                )
-            elif restore_content.restore_database:
-                for entry in KEEP_DATABASE:
-                    entrypath = config_dir / entry
-
-                    if entrypath.is_file():
-                        entrypath.unlink()
-                    elif entrypath.is_dir():
-                        shutil.rmtree(entrypath)
-
-                for entry in KEEP_DATABASE:
-                    shutil.copy(
-                        Path(tempdir, "homeassistant", "data", entry),
-                        config_dir,
-                    )
-
-
-def _write_restore_result_file(
-    config_dir: Path, success: bool, error: Exception | None
-) -> None:
-    """Write the restore result file."""
-    result_path = config_dir.joinpath(RESTORE_BACKUP_RESULT_FILE)
-    result_path.write_text(
-        json.dumps(
-            {
-                "success": success,
-                "error": str(error) if error else None,
-                "error_type": str(type(error).__name__) if error else None,
-            }
-        ),
-        encoding="utf-8",
-    )
-
-
-def restore_backup(config_dir_path: str) -> bool:
-    """Restore the backup file if any.
-
-    Returns True if a restore backup file was found and restored, False otherwise.
-    """
-    config_dir = Path(config_dir_path)
-    if not (restore_content := restore_backup_file_content(config_dir)):
-        return False
-
-    logging.basicConfig(stream=sys.stdout, level=logging.INFO)
-    backup_file_path = restore_content.backup_file_path
-    _LOGGER.info("Restoring %s", backup_file_path)
-    try:
-        _extract_backup(
-            config_dir=config_dir,
-            restore_content=restore_content,
-        )
-    except FileNotFoundError as err:
-        file_not_found = ValueError(f"Backup file {backup_file_path} does not exist")
-        _write_restore_result_file(config_dir, False, file_not_found)
-        raise file_not_found from err
-    except Exception as err:
-        _write_restore_result_file(config_dir, False, err)
-        raise
-    else:
-        _write_restore_result_file(config_dir, True, None)
-    if restore_content.remove_after_restore:
-        backup_file_path.unlink(missing_ok=True)
-    _LOGGER.info("Restore complete, restarting")
-    return True

homeassistant/block_async_io.py

@@ -31,7 +31,7 @@ def _check_import_call_allowed(mapped_args: dict[str, Any]) -> bool:
 def _check_file_allowed(mapped_args: dict[str, Any]) -> bool:
     # If the file is in /proc we can ignore it.
     args = mapped_args["args"]
-    path = args[0] if type(args[0]) is str else str(args[0])
+    path = args[0] if type(args[0]) is str else str(args[0])  # noqa: E721
     return path.startswith(ALLOWED_FILE_PREFIXES)
 
 
@@ -50,12 +50,6 @@ def _check_sleep_call_allowed(mapped_args: dict[str, Any]) -> bool:
     return False
 
 
-def _check_load_verify_locations_call_allowed(mapped_args: dict[str, Any]) -> bool:
-    # If only cadata is passed, we can ignore it
-    kwargs = mapped_args.get("kwargs")
-    return bool(kwargs and len(kwargs) == 1 and "cadata" in kwargs)
-
-
 @dataclass(slots=True, frozen=True)
 class BlockingCall:
     """Class to hold information about a blocking call."""
@@ -164,7 +158,7 @@ _BLOCKING_CALLS: tuple[BlockingCall, ...] = (
         original_func=SSLContext.load_verify_locations,
         object=SSLContext,
         function="load_verify_locations",
-        check_allowed=_check_load_verify_locations_call_allowed,
+        check_allowed=None,
         strict=False,
         strict_core=False,
         skip_for_tests=True,
@@ -178,15 +172,6 @@ _BLOCKING_CALLS: tuple[BlockingCall, ...] = (
         strict_core=False,
         skip_for_tests=True,
     ),
-    BlockingCall(
-        original_func=SSLContext.set_default_verify_paths,
-        object=SSLContext,
-        function="set_default_verify_paths",
-        check_allowed=None,
-        strict=False,
-        strict_core=False,
-        skip_for_tests=True,
-    ),
     BlockingCall(
         original_func=Path.open,
         object=Path,

homeassistant/bootstrap.py

@@ -53,7 +53,6 @@ from .components import (
     logbook as logbook_pre_import,  # noqa: F401
     lovelace as lovelace_pre_import,  # noqa: F401
     onboarding as onboarding_pre_import,  # noqa: F401
-    person as person_pre_import,  # noqa: F401
     recorder as recorder_import,  # noqa: F401 - not named pre_import since it has requirements
     repairs as repairs_pre_import,  # noqa: F401
     search as search_pre_import,  # noqa: F401
@@ -71,31 +70,26 @@ from .const import (
     REQUIRED_NEXT_PYTHON_VER,
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
-from .core_config import async_process_ha_core_config
 from .exceptions import HomeAssistantError
 from .helpers import (
     area_registry,
     category_registry,
-    condition,
     config_validation as cv,
     device_registry,
     entity,
     entity_registry,
     floor_registry,
-    frame,
     issue_registry,
     label_registry,
     recorder,
     restore_state,
     template,
     translation,
-    trigger,
 )
 from .helpers.dispatcher import async_dispatcher_send_internal
 from .helpers.storage import get_internal_store_manager
-from .helpers.system_info import async_get_system_info
+from .helpers.system_info import async_get_system_info, is_official_image
 from .helpers.typing import ConfigType
-from .loader import Integration
 from .setup import (
     # _setup_started is marked as protected to make it clear
     # that it is not part of the public API and should not be used
@@ -111,17 +105,11 @@ from .util.async_ import create_eager_task
 from .util.hass_dict import HassKey
 from .util.logging import async_activate_log_queue_handler
 from .util.package import async_get_user_site, is_docker_env, is_virtual_env
-from .util.system_info import is_official_image
 
 with contextlib.suppress(ImportError):
     # Ensure anyio backend is imported to avoid it being imported in the event loop
     from anyio._backends import _asyncio  # noqa: F401
 
-with contextlib.suppress(ImportError):
-    # httpx will import trio if it is installed which does
-    # blocking I/O in the event loop. We want to avoid that.
-    import trio  # noqa: F401
-
 
 if TYPE_CHECKING:
     from .runner import RuntimeConfig
@@ -139,12 +127,14 @@ DATA_REGISTRIES_LOADED: HassKey[None] = HassKey("bootstrap_registries_loaded")
 LOG_SLOW_STARTUP_INTERVAL = 60
 SLOW_STARTUP_CHECK_INTERVAL = 1
 
-STAGE_0_SUBSTAGE_TIMEOUT = 60
 STAGE_1_TIMEOUT = 120
 STAGE_2_TIMEOUT = 300
 WRAP_UP_TIMEOUT = 300
 COOLDOWN_TIME = 60
 
+
+DEBUGGER_INTEGRATIONS = {"debugpy"}
+
 # Core integrations are unconditionally loaded
 CORE_INTEGRATIONS = {"homeassistant", "persistent_notification"}
 
@@ -155,10 +145,6 @@ LOGGING_AND_HTTP_DEPS_INTEGRATIONS = {
     "isal",
     # Set log levels
     "logger",
-    # Ensure network config is available
-    # before hassio or any other integration is
-    # loaded that might create an aiohttp client session
-    "network",
     # Error logging
     "system_log",
     "sentry",
@@ -169,27 +155,12 @@ FRONTEND_INTEGRATIONS = {
     # visible in frontend
     "frontend",
 }
-# Stage 0 is divided into substages. Each substage has a name, a set of integrations and a timeout.
-# The substage containing recorder should have no timeout, as it could cancel a database migration.
-# Recorder freezes "recorder" timeout during a migration, but it does not freeze other timeouts.
-# If we add timeouts to the frontend substages, we should make sure they don't apply in recovery mode.
-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
-    ("recorder", {"recorder"}, None),
-    # Start up debuggers. Start these first in case they want to wait.
-    ("debugger", {"debugpy"}, STAGE_0_SUBSTAGE_TIMEOUT),
-    # Zeroconf is used for mdns resolution in aiohttp client helper.
-    ("zeroconf", {"zeroconf"}, STAGE_0_SUBSTAGE_TIMEOUT),
-)
-
-DISCOVERY_INTEGRATIONS = ("bluetooth", "dhcp", "ssdp", "usb")
-# Stage 1 integrations are not to be preimported in bootstrap.
+RECORDER_INTEGRATIONS = {
+    # Setup after frontend
+    # To record data
+    "recorder",
+}
+DISCOVERY_INTEGRATIONS = ("bluetooth", "dhcp", "ssdp", "usb", "zeroconf")
 STAGE_1_INTEGRATIONS = {
     # We need to make sure discovery integrations
     # update their deps before stage 2 integrations
@@ -204,7 +175,6 @@ STAGE_1_INTEGRATIONS = {
     # Ensure supervisor is available
     "hassio",
 }
-
 DEFAULT_INTEGRATIONS = {
     # These integrations are set up unless recovery mode is activated.
     #
@@ -214,7 +184,6 @@ DEFAULT_INTEGRATIONS = {
     "backup",
     "frontend",
     "hardware",
-    "labs",
     "logger",
     "network",
     "system_health",
@@ -246,12 +215,22 @@ DEFAULT_INTEGRATIONS_SUPERVISOR = {
     # These integrations are set up if using the Supervisor
     "hassio",
 }
-
 CRITICAL_INTEGRATIONS = {
     # Recovery mode is activated if these integrations fail to set up
     "frontend",
 }
 
+SETUP_ORDER = (
+    # Load logging and http deps as soon as possible
+    ("logging, http deps", LOGGING_AND_HTTP_DEPS_INTEGRATIONS),
+    # Setup frontend
+    ("frontend", FRONTEND_INTEGRATIONS),
+    # Setup recorder
+    ("recorder", RECORDER_INTEGRATIONS),
+    # Start up debuggers. Start these first in case they want to wait.
+    ("debugger", DEBUGGER_INTEGRATIONS),
+)
+
 #
 # Storage keys we are likely to load during startup
 # in order of when we expect to load them.
@@ -272,7 +251,6 @@ PRELOAD_STORAGE = [
     "assist_pipeline.pipelines",
     "core.analytics",
     "auth_module.totp",
-    "backup",
 ]
 
 
@@ -303,6 +281,14 @@ async def async_setup_hass(
 
         return hass
 
+    async def stop_hass(hass: core.HomeAssistant) -> None:
+        """Stop hass."""
+        # Ask integrations to shut down. It's messy but we can't
+        # do a clean stop without knowing what is broken
+        with contextlib.suppress(TimeoutError):
+            async with hass.timeout.async_timeout(10):
+                await hass.async_stop()
+
     hass = await create_hass()
 
     if runtime_config.skip_pip or runtime_config.skip_pip_packages:
@@ -318,10 +304,10 @@ async def async_setup_hass(
 
     block_async_io.enable()
 
-    if not (recovery_mode := runtime_config.recovery_mode):
-        config_dict = None
-        basic_setup_success = False
+    config_dict = None
+    basic_setup_success = False
 
+    if not (recovery_mode := runtime_config.recovery_mode):
         await hass.async_add_executor_job(conf_util.process_ha_config_upgrade, hass)
 
         try:
@@ -335,50 +321,43 @@ async def async_setup_hass(
             if not is_virtual_env():
                 await async_mount_local_lib_path(runtime_config.config_dir)
 
-            if hass.config.safe_mode:
-                _LOGGER.info("Starting in safe mode")
-
             basic_setup_success = (
                 await async_from_config_dict(config_dict, hass) is not None
             )
 
-        if config_dict is None:
-            recovery_mode = True
-            await hass.async_stop(force=True)
-            hass = await create_hass()
+    if config_dict is None:
+        recovery_mode = True
+        await stop_hass(hass)
+        hass = await create_hass()
 
-        elif not basic_setup_success:
-            _LOGGER.warning(
-                "Unable to set up core integrations. Activating recovery mode"
-            )
-            recovery_mode = True
-            await hass.async_stop(force=True)
-            hass = await create_hass()
+    elif not basic_setup_success:
+        _LOGGER.warning("Unable to set up core integrations. Activating recovery mode")
+        recovery_mode = True
+        await stop_hass(hass)
+        hass = await create_hass()
 
-        elif any(
-            domain not in hass.config.components for domain in CRITICAL_INTEGRATIONS
-        ):
-            _LOGGER.warning(
-                "Detected that %s did not load. Activating recovery mode",
-                ",".join(CRITICAL_INTEGRATIONS),
-            )
+    elif any(domain not in hass.config.components for domain in CRITICAL_INTEGRATIONS):
+        _LOGGER.warning(
+            "Detected that %s did not load. Activating recovery mode",
+            ",".join(CRITICAL_INTEGRATIONS),
+        )
 
-            old_config = hass.config
-            old_logging = hass.data.get(DATA_LOGGING)
+        old_config = hass.config
+        old_logging = hass.data.get(DATA_LOGGING)
 
-            recovery_mode = True
-            await hass.async_stop(force=True)
-            hass = await create_hass()
+        recovery_mode = True
+        await stop_hass(hass)
+        hass = await create_hass()
 
-            if old_logging:
-                hass.data[DATA_LOGGING] = old_logging
-            hass.config.debug = old_config.debug
-            hass.config.skip_pip = old_config.skip_pip
-            hass.config.skip_pip_packages = old_config.skip_pip_packages
-            hass.config.internal_url = old_config.internal_url
-            hass.config.external_url = old_config.external_url
-            # Setup loader cache after the config dir has been set
-            loader.async_setup(hass)
+        if old_logging:
+            hass.data[DATA_LOGGING] = old_logging
+        hass.config.debug = old_config.debug
+        hass.config.skip_pip = old_config.skip_pip
+        hass.config.skip_pip_packages = old_config.skip_pip_packages
+        hass.config.internal_url = old_config.internal_url
+        hass.config.external_url = old_config.external_url
+        # Setup loader cache after the config dir has been set
+        loader.async_setup(hass)
 
     if recovery_mode:
         _LOGGER.info("Starting in recovery mode")
@@ -390,6 +369,8 @@ async def async_setup_hass(
             {"recovery_mode": {}, "http": http_conf},
             hass,
         )
+    elif hass.config.safe_mode:
+        _LOGGER.info("Starting in safe mode")
 
     if runtime_config.open_ui:
         hass.add_job(open_hass_ui, hass)
@@ -399,7 +380,7 @@ async def async_setup_hass(
 
 def open_hass_ui(hass: core.HomeAssistant) -> None:
     """Open the UI."""
-    import webbrowser  # noqa: PLC0415
+    import webbrowser  # pylint: disable=import-outside-toplevel
 
     if hass.config.api is None or "frontend" not in hass.config.components:
         _LOGGER.warning("Cannot launch the UI because frontend not loaded")
@@ -439,10 +420,9 @@ async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
     if DATA_REGISTRIES_LOADED in hass.data:
         return
     hass.data[DATA_REGISTRIES_LOADED] = None
-    entity.async_setup(hass)
-    frame.async_setup(hass)
-    template.async_setup(hass)
     translation.async_setup(hass)
+    entity.async_setup(hass)
+    template.async_setup(hass)
     await asyncio.gather(
         create_eager_task(get_internal_store_manager(hass).async_initialize()),
         create_eager_task(area_registry.async_load(hass)),
@@ -457,8 +437,6 @@ async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
         create_eager_task(restore_state.async_load(hass)),
         create_eager_task(hass.config_entries.async_initialize()),
         create_eager_task(async_get_system_info(hass)),
-        create_eager_task(condition.async_setup(hass)),
-        create_eager_task(trigger.async_setup(hass)),
     )
 
 
@@ -501,7 +479,7 @@ async def async_from_config_dict(
     core_config = config.get(core.DOMAIN, {})
 
     try:
-        await async_process_ha_core_config(hass, core_config)
+        await conf_util.async_process_ha_core_config(hass, core_config)
     except vol.Invalid as config_err:
         conf_util.async_log_schema_error(config_err, core.DOMAIN, core_config, hass)
         async_notify_setup_error(hass, core.DOMAIN)
@@ -536,7 +514,7 @@ async def async_from_config_dict(
         issue_registry.async_create_issue(
             hass,
             core.DOMAIN,
-            f"python_version_{required_python_version}",
+            "python_version",
             is_fixable=False,
             severity=issue_registry.IssueSeverity.WARNING,
             breaks_in_ha_version=REQUIRED_NEXT_PYTHON_HA_RELEASE,
@@ -568,7 +546,8 @@ async def async_enable_logging(
 
     if not log_no_color:
         try:
-            from colorlog import ColoredFormatter  # noqa: PLC0415
+            # pylint: disable-next=import-outside-toplevel
+            from colorlog import ColoredFormatter
 
             # basicConfig must be called after importing colorlog in order to
             # ensure that the handlers it sets up wraps the correct streams.
@@ -619,37 +598,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)
 
@@ -667,10 +643,11 @@ def _create_log_file(
         err_handler = _RotatingFileHandlerWithoutShouldRollOver(
             err_log_path, backupCount=1
         )
-        try:
-            err_handler.doRollover()
-        except OSError as err:
-            _LOGGER.error("Error rolling over log file: %s", err)
+
+    try:
+        err_handler.doRollover()
+    except OSError as err:
+        _LOGGER.error("Error rolling over log file: %s", err)
 
     return err_handler
 
@@ -699,12 +676,13 @@ async def async_mount_local_lib_path(config_dir: str) -> str:
     return deps_dir
 
 
+@core.callback
 def _get_domains(hass: core.HomeAssistant, config: dict[str, Any]) -> set[str]:
     """Get domains of components to set up."""
-    # The common config section [homeassistant] could be filtered here,
-    # but that is not necessary, since it corresponds to the core integration,
-    # that is always unconditionally loaded.
-    domains = {cv.domain_key(key) for key in config}
+    # Filter out the repeating and common config section [homeassistant]
+    domains = {
+        domain for key in config if (domain := cv.domain_key(key)) != core.DOMAIN
+    }
 
     # Add config entry and default domains
     if not hass.config.recovery_mode:
@@ -720,251 +698,6 @@ def _get_domains(hass: core.HomeAssistant, config: dict[str, Any]) -> set[str]:
     return domains
 
 
-async def _async_resolve_domains_and_preload(
-    hass: core.HomeAssistant, config: dict[str, Any]
-) -> tuple[dict[str, Integration], dict[str, Integration]]:
-    """Resolve all dependencies and return integrations to set up.
-
-    The return value is a tuple of two dictionaries:
-    - The first dictionary contains integrations
-      specified by the configuration (including config entries).
-    - The second dictionary contains the same integrations as the first dictionary
-      together with all their dependencies.
-    """
-    domains_to_setup = _get_domains(hass, config)
-
-    # Also process all base platforms since we do not require the manifest
-    # to list them as dependencies.
-    # We want to later avoid lock contention when multiple integrations try to load
-    # their manifests at once.
-    #
-    # Additionally process integrations that are defined under base platforms
-    # to speed things up.
-    # For example if we have
-    # sensor:
-    #   - platform: template
-    #
-    # `template` has to be loaded to validate the config for sensor.
-    # The more platforms under `sensor:`, the longer
-    # it will take to finish setup for `sensor` because each of these
-    # platforms has to be imported before we can validate the config.
-    #
-    # Thankfully we are migrating away from the platform pattern
-    # so this will be less of a problem in the future.
-    platform_integrations = conf_util.extract_platform_integrations(
-        config, BASE_PLATFORMS
-    )
-    additional_domains_to_process = {
-        *BASE_PLATFORMS,
-        *chain.from_iterable(platform_integrations.values()),
-    }
-
-    # Resolve all dependencies so we know all integrations
-    # that will have to be loaded and start right-away
-    integrations_or_excs = await loader.async_get_integrations(
-        hass, {*domains_to_setup, *additional_domains_to_process}
-    )
-    # Eliminate those missing or with invalid manifest
-    integrations_to_process = {
-        domain: itg
-        for domain, itg in integrations_or_excs.items()
-        if isinstance(itg, Integration)
-    }
-    integrations_dependencies = await loader.resolve_integrations_dependencies(
-        hass, integrations_to_process.values()
-    )
-    # Eliminate those without valid dependencies
-    integrations_to_process = {
-        domain: integrations_to_process[domain] for domain in integrations_dependencies
-    }
-
-    integrations_to_setup = {
-        domain: itg
-        for domain, itg in integrations_to_process.items()
-        if domain in domains_to_setup
-    }
-    all_integrations_to_setup = integrations_to_setup.copy()
-    all_integrations_to_setup.update(
-        (dep, loader.async_get_loaded_integration(hass, dep))
-        for domain in integrations_to_setup
-        for dep in integrations_dependencies[domain].difference(
-            all_integrations_to_setup
-        )
-    )
-
-    # Gather requirements for all integrations,
-    # their dependencies and after dependencies.
-    # To gather all the requirements we must ignore exceptions here.
-    # The exceptions will be detected and handled later in the bootstrap process.
-    integrations_after_dependencies = (
-        await loader.resolve_integrations_after_dependencies(
-            hass, integrations_to_process.values(), ignore_exceptions=True
-        )
-    )
-    integrations_requirements = {
-        domain: itg.requirements for domain, itg in integrations_to_process.items()
-    }
-    integrations_requirements.update(
-        (dep, loader.async_get_loaded_integration(hass, dep).requirements)
-        for deps in integrations_after_dependencies.values()
-        for dep in deps.difference(integrations_requirements)
-    )
-    all_requirements = set(chain.from_iterable(integrations_requirements.values()))
-
-    # Optimistically check if requirements are already installed
-    # ahead of setting up the integrations so we can prime the cache
-    # We do not wait for this since it's an optimization only
-    hass.async_create_background_task(
-        requirements.async_load_installed_versions(hass, all_requirements),
-        "check installed requirements",
-        eager_start=True,
-    )
-
-    # Start loading translations for all integrations we are going to set up
-    # in the background so they are ready when we need them. This avoids a
-    # lot of waiting for the translation load lock and a thundering herd of
-    # tasks trying to load the same translations at the same time as each
-    # integration is loaded.
-    #
-    # We do not wait for this since as soon as the task runs it will
-    # hold the translation load lock and if anything is fast enough to
-    # wait for the translation load lock, loading will be done by the
-    # time it gets to it.
-    translations_to_load = {*all_integrations_to_setup, *additional_domains_to_process}
-    hass.async_create_background_task(
-        translation.async_load_integrations(hass, translations_to_load),
-        "load translations",
-        eager_start=True,
-    )
-
-    # Preload storage for all integrations we are going to set up
-    # so we do not have to wait for it to be loaded when we need it
-    # in the setup process.
-    hass.async_create_background_task(
-        get_internal_store_manager(hass).async_preload(
-            [*PRELOAD_STORAGE, *all_integrations_to_setup]
-        ),
-        "preload storage",
-        eager_start=True,
-    )
-
-    return integrations_to_setup, all_integrations_to_setup
-
-
-async def _async_set_up_integrations(
-    hass: core.HomeAssistant, config: dict[str, Any]
-) -> None:
-    """Set up all the integrations."""
-    watcher = _WatchPendingSetups(hass, _setup_started(hass))
-    watcher.async_start()
-
-    integrations, all_integrations = await _async_resolve_domains_and_preload(
-        hass, config
-    )
-    # Detect all cycles
-    integrations_after_dependencies = (
-        await loader.resolve_integrations_after_dependencies(
-            hass, all_integrations.values(), set(all_integrations)
-        )
-    )
-    all_domains = set(integrations_after_dependencies)
-    domains = set(integrations) & all_domains
-
-    _LOGGER.info(
-        "Domains to be set up: %s\nDependencies: %s",
-        domains or "{}",
-        (all_domains - domains) or "{}",
-    )
-
-    async_set_domains_to_be_loaded(hass, all_domains)
-
-    # Initialize recorder
-    if "recorder" in all_domains:
-        recorder.async_initialize_recorder(hass)
-
-    stages: list[tuple[str, set[str], int | None]] = [
-        *(
-            (name, domain_group, timeout)
-            for name, domain_group, timeout in STAGE_0_INTEGRATIONS
-        ),
-        ("1", STAGE_1_INTEGRATIONS, STAGE_1_TIMEOUT),
-        ("2", domains, STAGE_2_TIMEOUT),
-    ]
-
-    _LOGGER.info("Setting up stage 0")
-    for name, domain_group, timeout in stages:
-        stage_domains_unfiltered = domain_group & all_domains
-        if not stage_domains_unfiltered:
-            _LOGGER.info("Nothing to set up in stage %s: %s", name, domain_group)
-            continue
-
-        stage_domains = stage_domains_unfiltered - hass.config.components
-        if not stage_domains:
-            _LOGGER.info("Already set up stage %s: %s", name, stage_domains_unfiltered)
-            continue
-
-        stage_dep_domains_unfiltered = {
-            dep
-            for domain in stage_domains
-            for dep in integrations_after_dependencies[domain]
-            if dep not in stage_domains
-        }
-        stage_dep_domains = stage_dep_domains_unfiltered - hass.config.components
-
-        stage_all_domains = stage_domains | stage_dep_domains
-
-        _LOGGER.info(
-            "Setting up stage %s: %s; already set up: %s\n"
-            "Dependencies: %s; already set up: %s",
-            name,
-            stage_domains,
-            (stage_domains_unfiltered - stage_domains) or "{}",
-            stage_dep_domains or "{}",
-            (stage_dep_domains_unfiltered - stage_dep_domains) or "{}",
-        )
-
-        if timeout is None:
-            await _async_setup_multi_components(hass, stage_all_domains, config)
-            continue
-        try:
-            async with hass.timeout.async_timeout(
-                timeout,
-                cool_down=COOLDOWN_TIME,
-                cancel_message=f"Bootstrap stage {name} timeout",
-            ):
-                await _async_setup_multi_components(hass, stage_all_domains, config)
-        except TimeoutError:
-            _LOGGER.warning(
-                "Setup timed out for stage %s waiting on %s - moving forward",
-                name,
-                hass._active_tasks,  # noqa: SLF001
-            )
-
-    # Wrap up startup
-    _LOGGER.debug("Waiting for startup to wrap up")
-    try:
-        async with hass.timeout.async_timeout(
-            WRAP_UP_TIMEOUT,
-            cool_down=COOLDOWN_TIME,
-            cancel_message="Bootstrap startup wrap up timeout",
-        ):
-            await hass.async_block_till_done()
-    except TimeoutError:
-        _LOGGER.warning(
-            "Setup timed out for bootstrap waiting on %s - moving forward",
-            hass._active_tasks,  # noqa: SLF001
-        )
-
-    watcher.async_stop()
-
-    if _LOGGER.isEnabledFor(logging.DEBUG):
-        setup_time = async_get_setup_timings(hass)
-        _LOGGER.debug(
-            "Integration setup times: %s",
-            dict(sorted(setup_time.items(), key=itemgetter(1), reverse=True)),
-        )
-
-
 class _WatchPendingSetups:
     """Periodic log and dispatch of setups that are pending."""
 
@@ -1003,7 +736,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,
             )
 
@@ -1036,12 +769,14 @@ class _WatchPendingSetups:
             self._handle = None
 
 
-async def _async_setup_multi_components(
+async def async_setup_multi_components(
     hass: core.HomeAssistant,
     domains: set[str],
     config: dict[str, Any],
 ) -> None:
     """Set up multiple domains. Log on failure."""
+    # Avoid creating tasks for domains that were setup in a previous stage
+    domains_not_yet_setup = domains - hass.config.components
     # Create setup tasks for base platforms first since everything will have
     # to wait to be imported, and the sooner we can get the base platforms
     # loaded the sooner we can start loading the rest of the integrations.
@@ -1051,7 +786,9 @@ async def _async_setup_multi_components(
             f"setup component {domain}",
             eager_start=True,
         )
-        for domain in sorted(domains, key=SETUP_ORDER_SORT_KEY, reverse=True)
+        for domain in sorted(
+            domains_not_yet_setup, key=SETUP_ORDER_SORT_KEY, reverse=True
+        )
     }
     results = await asyncio.gather(*futures.values(), return_exceptions=True)
     for idx, domain in enumerate(futures):
@@ -1062,3 +799,278 @@ async def _async_setup_multi_components(
                 domain,
                 exc_info=(type(result), result, result.__traceback__),
             )
+
+
+async def _async_resolve_domains_to_setup(
+    hass: core.HomeAssistant, config: dict[str, Any]
+) -> tuple[set[str], dict[str, loader.Integration]]:
+    """Resolve all dependencies and return list of domains to set up."""
+    domains_to_setup = _get_domains(hass, config)
+    needed_requirements: set[str] = set()
+    platform_integrations = conf_util.extract_platform_integrations(
+        config, BASE_PLATFORMS
+    )
+    # Ensure base platforms that have platform integrations are added to
+    # to `domains_to_setup so they can be setup first instead of
+    # discovering them when later when a config entry setup task
+    # notices its needed and there is already a long line to use
+    # the import executor.
+    #
+    # For example if we have
+    # sensor:
+    #   - platform: template
+    #
+    # `template` has to be loaded to validate the config for sensor
+    # so we want to start loading `sensor` as soon as we know
+    # it will be needed. The more platforms under `sensor:`, the longer
+    # it will take to finish setup for `sensor` because each of these
+    # platforms has to be imported before we can validate the config.
+    #
+    # Thankfully we are migrating away from the platform pattern
+    # so this will be less of a problem in the future.
+    domains_to_setup.update(platform_integrations)
+
+    # Load manifests for base platforms and platform based integrations
+    # that are defined under base platforms right away since we do not require
+    # the manifest to list them as dependencies and we want to avoid the lock
+    # contention when multiple integrations try to load them at once
+    additional_manifests_to_load = {
+        *BASE_PLATFORMS,
+        *chain.from_iterable(platform_integrations.values()),
+    }
+
+    translations_to_load = additional_manifests_to_load.copy()
+
+    # Resolve all dependencies so we know all integrations
+    # that will have to be loaded and start right-away
+    integration_cache: dict[str, loader.Integration] = {}
+    to_resolve: set[str] = domains_to_setup
+    while to_resolve or additional_manifests_to_load:
+        old_to_resolve: set[str] = to_resolve
+        to_resolve = set()
+
+        if additional_manifests_to_load:
+            to_get = {*old_to_resolve, *additional_manifests_to_load}
+            additional_manifests_to_load.clear()
+        else:
+            to_get = old_to_resolve
+
+        manifest_deps: set[str] = set()
+        resolve_dependencies_tasks: list[asyncio.Task[bool]] = []
+        integrations_to_process: list[loader.Integration] = []
+
+        for domain, itg in (await loader.async_get_integrations(hass, to_get)).items():
+            if not isinstance(itg, loader.Integration):
+                continue
+            integration_cache[domain] = itg
+            needed_requirements.update(itg.requirements)
+
+            # Make sure manifests for dependencies are loaded in the next
+            # loop to try to group as many as manifest loads in a single
+            # call to avoid the creating one-off executor jobs later in
+            # the setup process
+            additional_manifests_to_load.update(
+                dep
+                for dep in chain(itg.dependencies, itg.after_dependencies)
+                if dep not in integration_cache
+            )
+
+            if domain not in old_to_resolve:
+                continue
+
+            integrations_to_process.append(itg)
+            manifest_deps.update(itg.dependencies)
+            manifest_deps.update(itg.after_dependencies)
+            if not itg.all_dependencies_resolved:
+                resolve_dependencies_tasks.append(
+                    create_eager_task(
+                        itg.resolve_dependencies(),
+                        name=f"resolve dependencies {domain}",
+                        loop=hass.loop,
+                    )
+                )
+
+        if unseen_deps := manifest_deps - integration_cache.keys():
+            # If there are dependencies, try to preload all
+            # the integrations manifest at once and add them
+            # to the list of requirements we need to install
+            # so we can try to check if they are already installed
+            # in a single call below which avoids each integration
+            # having to wait for the lock to do it individually
+            deps = await loader.async_get_integrations(hass, unseen_deps)
+            for dependant_domain, dependant_itg in deps.items():
+                if isinstance(dependant_itg, loader.Integration):
+                    integration_cache[dependant_domain] = dependant_itg
+                    needed_requirements.update(dependant_itg.requirements)
+
+        if resolve_dependencies_tasks:
+            await asyncio.gather(*resolve_dependencies_tasks)
+
+        for itg in integrations_to_process:
+            try:
+                all_deps = itg.all_dependencies
+            except RuntimeError:
+                # Integration.all_dependencies raises RuntimeError if
+                # dependencies could not be resolved
+                continue
+            for dep in all_deps:
+                if dep in domains_to_setup:
+                    continue
+                domains_to_setup.add(dep)
+                to_resolve.add(dep)
+
+    _LOGGER.info("Domains to be set up: %s", domains_to_setup)
+
+    # Optimistically check if requirements are already installed
+    # ahead of setting up the integrations so we can prime the cache
+    # We do not wait for this since its an optimization only
+    hass.async_create_background_task(
+        requirements.async_load_installed_versions(hass, needed_requirements),
+        "check installed requirements",
+        eager_start=True,
+    )
+
+    #
+    # Only add the domains_to_setup after we finish resolving
+    # as new domains are likely to added in the process
+    #
+    translations_to_load.update(domains_to_setup)
+    # Start loading translations for all integrations we are going to set up
+    # in the background so they are ready when we need them. This avoids a
+    # lot of waiting for the translation load lock and a thundering herd of
+    # tasks trying to load the same translations at the same time as each
+    # integration is loaded.
+    #
+    # We do not wait for this since as soon as the task runs it will
+    # hold the translation load lock and if anything is fast enough to
+    # wait for the translation load lock, loading will be done by the
+    # time it gets to it.
+    hass.async_create_background_task(
+        translation.async_load_integrations(hass, translations_to_load),
+        "load translations",
+        eager_start=True,
+    )
+
+    # Preload storage for all integrations we are going to set up
+    # so we do not have to wait for it to be loaded when we need it
+    # in the setup process.
+    hass.async_create_background_task(
+        get_internal_store_manager(hass).async_preload(
+            [*PRELOAD_STORAGE, *domains_to_setup]
+        ),
+        "preload storage",
+        eager_start=True,
+    )
+
+    return domains_to_setup, integration_cache
+
+
+async def _async_set_up_integrations(
+    hass: core.HomeAssistant, config: dict[str, Any]
+) -> None:
+    """Set up all the integrations."""
+    watcher = _WatchPendingSetups(hass, _setup_started(hass))
+    watcher.async_start()
+
+    domains_to_setup, integration_cache = await _async_resolve_domains_to_setup(
+        hass, config
+    )
+
+    # Initialize recorder
+    if "recorder" in domains_to_setup:
+        recorder.async_initialize_recorder(hass)
+
+    pre_stage_domains = [
+        (name, domains_to_setup & domain_group) for name, domain_group in SETUP_ORDER
+    ]
+
+    # calculate what components to setup in what stage
+    stage_1_domains: set[str] = set()
+
+    # Find all dependencies of any dependency of any stage 1 integration that
+    # we plan on loading and promote them to stage 1. This is done only to not
+    # get misleading log messages
+    deps_promotion: set[str] = STAGE_1_INTEGRATIONS
+    while deps_promotion:
+        old_deps_promotion = deps_promotion
+        deps_promotion = set()
+
+        for domain in old_deps_promotion:
+            if domain not in domains_to_setup or domain in stage_1_domains:
+                continue
+
+            stage_1_domains.add(domain)
+
+            if (dep_itg := integration_cache.get(domain)) is None:
+                continue
+
+            deps_promotion.update(dep_itg.all_dependencies)
+
+    stage_2_domains = domains_to_setup - stage_1_domains
+
+    for name, domain_group in pre_stage_domains:
+        if domain_group:
+            stage_2_domains -= domain_group
+            _LOGGER.info("Setting up %s: %s", name, domain_group)
+            to_be_loaded = domain_group.copy()
+            to_be_loaded.update(
+                dep
+                for domain in domain_group
+                if (integration := integration_cache.get(domain)) is not None
+                for dep in integration.all_dependencies
+            )
+            async_set_domains_to_be_loaded(hass, to_be_loaded)
+            await async_setup_multi_components(hass, domain_group, config)
+
+    # Enables after dependencies when setting up stage 1 domains
+    async_set_domains_to_be_loaded(hass, stage_1_domains)
+
+    # Start setup
+    if stage_1_domains:
+        _LOGGER.info("Setting up stage 1: %s", stage_1_domains)
+        try:
+            async with hass.timeout.async_timeout(
+                STAGE_1_TIMEOUT, cool_down=COOLDOWN_TIME
+            ):
+                await async_setup_multi_components(hass, stage_1_domains, config)
+        except TimeoutError:
+            _LOGGER.warning(
+                "Setup timed out for stage 1 waiting on %s - moving forward",
+                hass._active_tasks,  # noqa: SLF001
+            )
+
+    # Add after dependencies when setting up stage 2 domains
+    async_set_domains_to_be_loaded(hass, stage_2_domains)
+
+    if stage_2_domains:
+        _LOGGER.info("Setting up stage 2: %s", stage_2_domains)
+        try:
+            async with hass.timeout.async_timeout(
+                STAGE_2_TIMEOUT, cool_down=COOLDOWN_TIME
+            ):
+                await async_setup_multi_components(hass, stage_2_domains, config)
+        except TimeoutError:
+            _LOGGER.warning(
+                "Setup timed out for stage 2 waiting on %s - moving forward",
+                hass._active_tasks,  # noqa: SLF001
+            )
+
+    # Wrap up startup
+    _LOGGER.debug("Waiting for startup to wrap up")
+    try:
+        async with hass.timeout.async_timeout(WRAP_UP_TIMEOUT, cool_down=COOLDOWN_TIME):
+            await hass.async_block_till_done()
+    except TimeoutError:
+        _LOGGER.warning(
+            "Setup timed out for bootstrap waiting on %s - moving forward",
+            hass._active_tasks,  # noqa: SLF001
+        )
+
+    watcher.async_stop()
+
+    if _LOGGER.isEnabledFor(logging.DEBUG):
+        setup_time = async_get_setup_timings(hass)
+        _LOGGER.debug(
+            "Integration setup times: %s",
+            dict(sorted(setup_time.items(), key=itemgetter(1), reverse=True)),
+        )

homeassistant/brands/amazon.json

@@ -1,13 +1,5 @@
 {
   "domain": "amazon",
   "name": "Amazon",
-  "integrations": [
-    "alexa",
-    "alexa_devices",
-    "amazon_polly",
-    "aws",
-    "aws_s3",
-    "fire_tv",
-    "route53"
-  ]
+  "integrations": ["alexa", "amazon_polly", "aws", "fire_tv", "route53"]
 }

homeassistant/brands/aqara.json

@@ -1,5 +0,0 @@
-{
-  "domain": "aqara",
-  "name": "Aqara",
-  "iot_standards": ["matter", "zigbee"]
-}

homeassistant/brands/bosch.json

@@ -1,5 +0,0 @@
-{
-  "domain": "bosch",
-  "name": "Bosch",
-  "integrations": ["bosch_alarm", "bosch_shc", "home_connect"]
-}

homeassistant/brands/eltako.json

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

homeassistant/brands/eve.json

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

homeassistant/brands/frient.json

@@ -1,5 +0,0 @@
-{
-  "domain": "frient",
-  "name": "Frient",
-  "iot_standards": ["zigbee"]
-}

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,21 +2,18 @@
   "domain": "google",
   "name": "Google",
   "integrations": [
-    "google_air_quality",
     "google_assistant",
     "google_assistant_sdk",
     "google_cloud",
-    "google_drive",
+    "google_domains",
     "google_generative_ai_conversation",
     "google_mail",
     "google_maps",
-    "google_photos",
     "google_pubsub",
     "google_sheets",
     "google_tasks",
     "google_translate",
     "google_travel_time",
-    "google_weather",
     "google_wifi",
     "google",
     "nest",

homeassistant/brands/husqvarna.json

@@ -1,5 +0,0 @@
-{
-  "domain": "husqvarna",
-  "name": "Husqvarna",
-  "integrations": ["husqvarna_automower", "husqvarna_automower_ble"]
-}

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/lg.json

@@ -1,5 +1,5 @@
 {
   "domain": "lg",
   "name": "LG",
-  "integrations": ["lg_netcast", "lg_soundbar", "lg_thinq", "webostv"]
+  "integrations": ["lg_netcast", "lg_soundbar", "webostv"]
 }

homeassistant/brands/microsoft.json

@@ -2,17 +2,14 @@
   "domain": "microsoft",
   "name": "Microsoft",
   "integrations": [
-    "azure_data_explorer",
     "azure_devops",
     "azure_event_hub",
     "azure_service_bus",
-    "azure_storage",
     "microsoft_face_detect",
     "microsoft_face_identify",
     "microsoft_face",
     "microsoft",
     "msteams",
-    "onedrive",
     "xbox"
   ]
 }

homeassistant/brands/motionblinds.json

@@ -1,6 +1,5 @@
 {
   "domain": "motionblinds",
   "name": "Motionblinds",
-  "integrations": ["motion_blinds", "motionblinds_ble"],
-  "iot_standards": ["matter"]
+  "integrations": ["motion_blinds", "motionblinds_ble"]
 }

homeassistant/brands/nuki.json

@@ -1,6 +0,0 @@
-{
-  "domain": "nuki",
-  "name": "Nuki",
-  "integrations": ["nuki"],
-  "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/roth.json

@@ -1,5 +0,0 @@
-{
-  "domain": "roth",
-  "name": "Roth",
-  "integrations": ["touchline", "touchline_sl"]
-}

homeassistant/brands/sensorpush.json

@@ -1,5 +0,0 @@
-{
-  "domain": "sensorpush",
-  "name": "SensorPush",
-  "integrations": ["sensorpush", "sensorpush_cloud"]
-}

homeassistant/brands/shelly.json

@@ -1,6 +0,0 @@
-{
-  "domain": "shelly",
-  "name": "shelly",
-  "integrations": ["shelly"],
-  "iot_standards": ["zwave"]
-}

homeassistant/brands/sky.json

@@ -1,5 +0,0 @@
-{
-  "domain": "sky",
-  "name": "Sky",
-  "integrations": ["sky_hub", "sky_remote"]
-}

homeassistant/brands/slide.json

@@ -1,5 +0,0 @@
-{
-  "domain": "slide",
-  "name": "Slide",
-  "integrations": ["slide", "slide_local"]
-}

homeassistant/brands/sony.json

@@ -1,11 +1,5 @@
 {
   "domain": "sony",
   "name": "Sony",
-  "integrations": [
-    "braviatv",
-    "ps4",
-    "sony_projector",
-    "songpal",
-    "playstation_network"
-  ]
+  "integrations": ["braviatv", "ps4", "sony_projector", "songpal"]
 }

homeassistant/brands/switchbot.json

@@ -1,6 +1,5 @@
 {
   "domain": "switchbot",
   "name": "SwitchBot",
-  "integrations": ["switchbot", "switchbot_cloud"],
-  "iot_standards": ["matter"]
+  "integrations": ["switchbot", "switchbot_cloud"]
 }