Drop ignore-missing-annotations from pylint

.github/workflows/builder.yml

@@ -272,7 +272,7 @@ jobs:
     name: Build ${{ matrix.machine }} machine core image
     if: github.repository_owner == 'home-assistant'
     needs: ["init", "build_base"]
-    runs-on: ${{ matrix.runs-on }}
+    runs-on: ubuntu-latest
     permissions:
       contents: read # To check out the repository
       packages: write # To push to GHCR
@@ -294,21 +294,6 @@ jobs:
           - raspberrypi5-64
           - yellow
           - green
-        include:
-          # Default: aarch64 on native ARM runner
-          - arch: aarch64
-            runs-on: ubuntu-24.04-arm
-          # Overrides for amd64 machines
-          - machine: generic-x86-64
-            arch: amd64
-            runs-on: ubuntu-24.04
-          - machine: qemux86-64
-            arch: amd64
-            runs-on: ubuntu-24.04
-          # TODO: remove, intel-nuc is a legacy name for x86-64, renamed in 2021
-          - machine: intel-nuc
-            arch: amd64
-            runs-on: ubuntu-24.04
     steps:
       - name: Checkout the repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -336,9 +321,8 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build base image
-        uses: home-assistant/builder@6cb4fd3d1338b6e22d0958a4bcb53e0965ea63b4 # 2026.02.1
+        uses: home-assistant/builder@21bc64d76dad7a5184c67826aab41c6b6f89023a # 2025.11.0
         with:
-          image: ${{ matrix.arch }}
           args: |
             $BUILD_ARGS \
             --target /data/machine \

.github/workflows/ci.yaml

@@ -705,7 +705,7 @@ jobs:
         run: |
           . venv/bin/activate
           python --version
-          pylint --ignore-missing-annotations=y homeassistant
+          pylint homeassistant
       - name: Run pylint (partially)
         if: needs.info.outputs.test_full_suite == 'false'
         shell: bash
@@ -714,7 +714,7 @@ jobs:
         run: |
           . venv/bin/activate
           python --version
-          pylint --ignore-missing-annotations=y $(printf "homeassistant/components/%s " ${INTEGRATIONS_GLOB})
+          pylint $(printf "homeassistant/components/%s " ${INTEGRATIONS_GLOB})
 
   pylint-tests:
     name: Check pylint on tests

.strict-typing

@@ -583,7 +583,6 @@ homeassistant.components.vacuum.*
 homeassistant.components.vallox.*
 homeassistant.components.valve.*
 homeassistant.components.velbus.*
-homeassistant.components.velux.*
 homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*

CODEOWNERS

@@ -555,6 +555,8 @@ build.json @home-assistant/supervisor
 /tests/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /homeassistant/components/fritzbox/ @mib1185 @flabbamann
 /tests/components/fritzbox/ @mib1185 @flabbamann
+/homeassistant/components/fritzbox_callmonitor/ @cdce8p
+/tests/components/fritzbox_callmonitor/ @cdce8p
 /homeassistant/components/fronius/ @farmio
 /tests/components/fronius/ @farmio
 /homeassistant/components/frontend/ @home-assistant/frontend
@@ -1080,8 +1082,6 @@ build.json @home-assistant/supervisor
 /tests/components/mutesync/ @currentoor
 /homeassistant/components/my/ @home-assistant/core
 /tests/components/my/ @home-assistant/core
-/homeassistant/components/myneomitis/ @l-pr
-/tests/components/myneomitis/ @l-pr
 /homeassistant/components/mysensors/ @MartinHjelmare @functionpointer
 /tests/components/mysensors/ @MartinHjelmare @functionpointer
 /homeassistant/components/mystrom/ @fabaff

homeassistant/components/airos/__init__.py

@@ -23,7 +23,6 @@ from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator
 
 _PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
-    Platform.BUTTON,
     Platform.SENSOR,
 ]
 

homeassistant/components/airos/button.py

@@ -1,73 +0,0 @@
-"""AirOS button component for Home Assistant."""
-
-from __future__ import annotations
-
-import logging
-
-from airos.exceptions import AirOSException
-
-from homeassistant.components.button import (
-    ButtonDeviceClass,
-    ButtonEntity,
-    ButtonEntityDescription,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import DOMAIN, AirOSConfigEntry, AirOSDataUpdateCoordinator
-from .entity import AirOSEntity
-
-_LOGGER = logging.getLogger(__name__)
-
-PARALLEL_UPDATES = 0
-
-REBOOT_BUTTON = ButtonEntityDescription(
-    key="reboot",
-    device_class=ButtonDeviceClass.RESTART,
-    entity_registry_enabled_default=False,
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: AirOSConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the AirOS button from a config entry."""
-    async_add_entities([AirOSRebootButton(config_entry.runtime_data, REBOOT_BUTTON)])
-
-
-class AirOSRebootButton(AirOSEntity, ButtonEntity):
-    """Button to reboot device."""
-
-    entity_description: ButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: AirOSDataUpdateCoordinator,
-        description: ButtonEntityDescription,
-    ) -> None:
-        """Initialize the AirOS client button."""
-        super().__init__(coordinator)
-
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.derived.mac}_{description.key}"
-
-    async def async_press(self) -> None:
-        """Handle the button press to reboot the device."""
-        try:
-            await self.coordinator.airos_device.login()
-            result = await self.coordinator.airos_device.reboot()
-
-        except AirOSException as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect",
-            ) from err
-
-        if not result:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="reboot_failed",
-            ) from None

homeassistant/components/airos/config_flow.py

@@ -2,20 +2,16 @@
 
 from __future__ import annotations
 
-import asyncio
 from collections.abc import Mapping
 import logging
 from typing import Any
 
-from airos.discovery import airos_discover_devices
 from airos.exceptions import (
     AirOSConnectionAuthenticationError,
     AirOSConnectionSetupError,
     AirOSDataMissingError,
     AirOSDeviceConnectionError,
-    AirOSEndpointError,
     AirOSKeyDataMissingError,
-    AirOSListenerError,
 )
 import voluptuous as vol
 
@@ -34,35 +30,21 @@ from homeassistant.const import (
 )
 from homeassistant.data_entry_flow import section
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.selector import (
     TextSelector,
     TextSelectorConfig,
     TextSelectorType,
 )
-from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
-from .const import (
-    DEFAULT_SSL,
-    DEFAULT_USERNAME,
-    DEFAULT_VERIFY_SSL,
-    DEVICE_NAME,
-    DOMAIN,
-    HOSTNAME,
-    IP_ADDRESS,
-    MAC_ADDRESS,
-    SECTION_ADVANCED_SETTINGS,
-)
+from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN, SECTION_ADVANCED_SETTINGS
 from .coordinator import AirOS8
 
 _LOGGER = logging.getLogger(__name__)
 
-# Discovery duration in seconds, airOS announces every 20 seconds
-DISCOVER_INTERVAL: int = 30
-
-STEP_DISCOVERY_DATA_SCHEMA = vol.Schema(
+STEP_USER_DATA_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_USERNAME, default=DEFAULT_USERNAME): str,
+        vol.Required(CONF_HOST): str,
+        vol.Required(CONF_USERNAME, default="ubnt"): str,
         vol.Required(CONF_PASSWORD): str,
         vol.Required(SECTION_ADVANCED_SETTINGS): section(
             vol.Schema(
@@ -76,10 +58,6 @@ STEP_DISCOVERY_DATA_SCHEMA = vol.Schema(
     }
 )
 
-STEP_MANUAL_DATA_SCHEMA = STEP_DISCOVERY_DATA_SCHEMA.extend(
-    {vol.Required(CONF_HOST): str}
-)
-
 
 class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ubiquiti airOS."""
@@ -87,29 +65,14 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     VERSION = 2
     MINOR_VERSION = 1
 
-    _discovery_task: asyncio.Task | None = None
-
     def __init__(self) -> None:
         """Initialize the config flow."""
         super().__init__()
         self.airos_device: AirOS8
         self.errors: dict[str, str] = {}
-        self.discovered_devices: dict[str, dict[str, Any]] = {}
-        self.discovery_abort_reason: str | None = None
-        self.selected_device_info: dict[str, Any] = {}
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        self.errors = {}
-
-        return self.async_show_menu(
-            step_id="user", menu_options=["discovery", "manual"]
-        )
-
-    async def async_step_manual(
-        self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the manual input of host and credentials."""
         self.errors = {}
@@ -121,7 +84,7 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
                     data=validated_info["data"],
                 )
         return self.async_show_form(
-            step_id="manual", data_schema=STEP_MANUAL_DATA_SCHEMA, errors=self.errors
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=self.errors
         )
 
     async def _validate_and_get_device_info(
@@ -257,175 +220,3 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             ),
             errors=self.errors,
         )
-
-    async def async_step_discovery(
-        self,
-        discovery_info: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Start the discovery process."""
-        if self._discovery_task and self._discovery_task.done():
-            self._discovery_task = None
-
-            # Handle appropriate 'errors' as abort through progress_done
-            if self.discovery_abort_reason:
-                return self.async_show_progress_done(
-                    next_step_id=self.discovery_abort_reason
-                )
-
-            # Abort through progress_done if no devices were found
-            if not self.discovered_devices:
-                _LOGGER.debug(
-                    "No (new or unconfigured) airOS devices found during discovery"
-                )
-                return self.async_show_progress_done(
-                    next_step_id="discovery_no_devices"
-                )
-
-            # Skip selecting a device if only one new/unconfigured device was found
-            if len(self.discovered_devices) == 1:
-                self.selected_device_info = list(self.discovered_devices.values())[0]
-                return self.async_show_progress_done(next_step_id="configure_device")
-
-            return self.async_show_progress_done(next_step_id="select_device")
-
-        if not self._discovery_task:
-            self.discovered_devices = {}
-            self._discovery_task = self.hass.async_create_task(
-                self._async_run_discovery_with_progress()
-            )
-
-        # Show the progress bar and wait for discovery to complete
-        return self.async_show_progress(
-            step_id="discovery",
-            progress_action="discovering",
-            progress_task=self._discovery_task,
-            description_placeholders={"seconds": str(DISCOVER_INTERVAL)},
-        )
-
-    async def async_step_select_device(
-        self,
-        discovery_info: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Select a discovered device."""
-        if discovery_info is not None:
-            selected_mac = discovery_info[MAC_ADDRESS]
-            self.selected_device_info = self.discovered_devices[selected_mac]
-            return await self.async_step_configure_device()
-
-        list_options = {
-            mac: f"{device.get(HOSTNAME, mac)} ({device.get(IP_ADDRESS, DEVICE_NAME)})"
-            for mac, device in self.discovered_devices.items()
-        }
-
-        return self.async_show_form(
-            step_id="select_device",
-            data_schema=vol.Schema({vol.Required(MAC_ADDRESS): vol.In(list_options)}),
-        )
-
-    async def async_step_configure_device(
-        self,
-        user_input: dict[str, Any] | None = None,
-    ) -> ConfigFlowResult:
-        """Configure the selected device."""
-        self.errors = {}
-
-        if user_input is not None:
-            config_data = {
-                **user_input,
-                CONF_HOST: self.selected_device_info[IP_ADDRESS],
-            }
-            validated_info = await self._validate_and_get_device_info(config_data)
-
-            if validated_info:
-                return self.async_create_entry(
-                    title=validated_info["title"],
-                    data=validated_info["data"],
-                )
-
-        device_name = self.selected_device_info.get(
-            HOSTNAME, self.selected_device_info.get(IP_ADDRESS, DEVICE_NAME)
-        )
-        return self.async_show_form(
-            step_id="configure_device",
-            data_schema=STEP_DISCOVERY_DATA_SCHEMA,
-            errors=self.errors,
-            description_placeholders={"device_name": device_name},
-        )
-
-    async def _async_run_discovery_with_progress(self) -> None:
-        """Run discovery with an embedded progress update loop."""
-        progress_bar = self.hass.async_create_task(self._async_update_progress_bar())
-
-        known_mac_addresses = {
-            entry.unique_id.lower()
-            for entry in self.hass.config_entries.async_entries(DOMAIN)
-            if entry.unique_id
-        }
-
-        try:
-            devices = await airos_discover_devices(DISCOVER_INTERVAL)
-        except AirOSEndpointError:
-            self.discovery_abort_reason = "discovery_detect_error"
-        except AirOSListenerError:
-            self.discovery_abort_reason = "discovery_listen_error"
-        except Exception:
-            self.discovery_abort_reason = "discovery_failed"
-            _LOGGER.exception("An error occurred during discovery")
-        else:
-            self.discovered_devices = {
-                mac_addr: info
-                for mac_addr, info in devices.items()
-                if mac_addr.lower() not in known_mac_addresses
-            }
-            _LOGGER.debug(
-                "Discovery task finished. Found %s new devices",
-                len(self.discovered_devices),
-            )
-        finally:
-            progress_bar.cancel()
-
-    async def _async_update_progress_bar(self) -> None:
-        """Update progress bar every second."""
-        try:
-            for i in range(DISCOVER_INTERVAL):
-                progress = (i + 1) / DISCOVER_INTERVAL
-                self.async_update_progress(progress)
-                await asyncio.sleep(1)
-        except asyncio.CancelledError:
-            pass
-
-    async def async_step_dhcp(
-        self, discovery_info: DhcpServiceInfo
-    ) -> ConfigFlowResult:
-        """Automatically handle a DHCP discovered IP change."""
-        ip_address = discovery_info.ip
-        # python-airos defaults to upper for derived mac_address
-        normalized_mac = format_mac(discovery_info.macaddress).upper()
-        await self.async_set_unique_id(normalized_mac)
-
-        self._abort_if_unique_id_configured(updates={CONF_HOST: ip_address})
-        return self.async_abort(reason="unreachable")
-
-    async def async_step_discovery_no_devices(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Abort if discovery finds no (unconfigured) devices."""
-        return self.async_abort(reason="no_devices_found")
-
-    async def async_step_discovery_listen_error(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Abort if discovery is unable to listen on the port."""
-        return self.async_abort(reason="listen_error")
-
-    async def async_step_discovery_detect_error(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Abort if discovery receives incorrect broadcasts."""
-        return self.async_abort(reason="detect_error")
-
-    async def async_step_discovery_failed(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Abort if discovery fails for other reasons."""
-        return self.async_abort(reason="discovery_failed")

homeassistant/components/airos/const.py

@@ -12,10 +12,3 @@ DEFAULT_VERIFY_SSL = False
 DEFAULT_SSL = True
 
 SECTION_ADVANCED_SETTINGS = "advanced_settings"
-
-# Discovery related
-DEFAULT_USERNAME = "ubnt"
-HOSTNAME = "hostname"
-IP_ADDRESS = "ip_address"
-MAC_ADDRESS = "mac_address"
-DEVICE_NAME = "airOS device"

homeassistant/components/airos/manifest.json

@@ -3,7 +3,6 @@
   "name": "Ubiquiti airOS",
   "codeowners": ["@CoMPaTech"],
   "config_flow": true,
-  "dhcp": [{ "registered_devices": true }],
   "documentation": "https://www.home-assistant.io/integrations/airos",
   "integration_type": "device",
   "iot_class": "local_polling",

homeassistant/components/airos/strings.json

@@ -2,10 +2,6 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "detect_error": "Unable to process discovered devices data, check the documentation for supported devices",
-      "discovery_failed": "Unable to start discovery, check logs for details",
-      "listen_error": "Unable to start listening for devices",
-      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unique_id_mismatch": "Re-authentication should be used for the same device not a new one"
@@ -17,36 +13,37 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "flow_title": "Ubiquiti airOS device",
-    "progress": {
-      "connecting": "Connecting to the airOS device",
-      "discovering": "Listening for any airOS devices for {seconds} seconds"
-    },
     "step": {
-      "configure_device": {
+      "reauth_confirm": {
         "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
+          "password": "[%key:common::config_flow::data::password%]"
         },
         "data_description": {
-          "password": "[%key:component::airos::config::step::manual::data_description::password%]",
-          "username": "[%key:component::airos::config::step::manual::data_description::username%]"
+          "password": "[%key:component::airos::config::step::user::data_description::password%]"
+        }
+      },
+      "reconfigure": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "[%key:component::airos::config::step::user::data_description::password%]"
         },
-        "description": "Enter the username and password for {device_name}",
         "sections": {
           "advanced_settings": {
             "data": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data::ssl%]",
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data::ssl%]",
               "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
             },
             "data_description": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::ssl%]",
-              "verify_ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::verify_ssl%]"
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::ssl%]",
+              "verify_ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::verify_ssl%]"
             },
-            "name": "[%key:component::airos::config::step::manual::sections::advanced_settings::name%]"
+            "name": "[%key:component::airos::config::step::user::sections::advanced_settings::name%]"
           }
         }
       },
-      "manual": {
+      "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
           "password": "[%key:common::config_flow::data::password%]",
@@ -70,49 +67,6 @@
             "name": "Advanced settings"
           }
         }
-      },
-      "reauth_confirm": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "[%key:component::airos::config::step::manual::data_description::password%]"
-        }
-      },
-      "reconfigure": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "password": "[%key:component::airos::config::step::manual::data_description::password%]"
-        },
-        "sections": {
-          "advanced_settings": {
-            "data": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data::ssl%]",
-              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-            },
-            "data_description": {
-              "ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::ssl%]",
-              "verify_ssl": "[%key:component::airos::config::step::manual::sections::advanced_settings::data_description::verify_ssl%]"
-            },
-            "name": "[%key:component::airos::config::step::manual::sections::advanced_settings::name%]"
-          }
-        }
-      },
-      "select_device": {
-        "data": {
-          "mac_address": "Select the device to configure"
-        },
-        "data_description": {
-          "mac_address": "Select the device MAC address"
-        }
-      },
-      "user": {
-        "menu_options": {
-          "discovery": "Listen for airOS devices on the network",
-          "manual": "Manually configure airOS device"
-        }
       }
     }
   },
@@ -203,9 +157,6 @@
     },
     "key_data_missing": {
       "message": "Key data not returned from device"
-    },
-    "reboot_failed": {
-      "message": "The device did not accept the reboot request. Try again, or check your device web interface for errors."
     }
   }
 }

homeassistant/components/aladdin_connect/__init__.py

@@ -2,12 +2,10 @@
 
 from __future__ import annotations
 
-import aiohttp
 from genie_partner_sdk.client import AladdinConnectClient
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import (
     aiohttp_client,
     config_entry_oauth2_flow,
@@ -33,27 +31,11 @@ async def async_setup_entry(
 
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
 
-    try:
-        await session.async_ensure_token_valid()
-    except aiohttp.ClientResponseError as err:
-        if 400 <= err.status < 500:
-            raise ConfigEntryAuthFailed(err) from err
-        raise ConfigEntryNotReady from err
-    except aiohttp.ClientError as err:
-        raise ConfigEntryNotReady from err
-
     client = AladdinConnectClient(
         api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
     )
 
-    try:
-        doors = await client.get_doors()
-    except aiohttp.ClientResponseError as err:
-        if 400 <= err.status < 500:
-            raise ConfigEntryAuthFailed(err) from err
-        raise ConfigEntryNotReady from err
-    except aiohttp.ClientError as err:
-        raise ConfigEntryNotReady from err
+    doors = await client.get_doors()
 
     entry.runtime_data = {
         door.unique_id: AladdinConnectCoordinator(hass, entry, client, door)

homeassistant/components/aladdin_connect/api.py

@@ -11,18 +11,6 @@ API_URL = "https://twdvzuefzh.execute-api.us-east-2.amazonaws.com/v1"
 API_KEY = "k6QaiQmcTm2zfaNns5L1Z8duBtJmhDOW8JawlCC3"
 
 
-class AsyncConfigFlowAuth(Auth):
-    """Provide Aladdin Connect Genie authentication for config flow validation."""
-
-    def __init__(self, websession: ClientSession, access_token: str) -> None:
-        """Initialize Aladdin Connect Genie auth."""
-        super().__init__(websession, API_URL, access_token, API_KEY)
-
-    async def async_get_access_token(self) -> str:
-        """Return the access token."""
-        return self.access_token
-
-
 class AsyncConfigEntryAuth(Auth):
     """Provide Aladdin Connect Genie authentication tied to an OAuth2 based config entry."""
 

homeassistant/components/aladdin_connect/config_flow.py

@@ -4,14 +4,12 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
-from genie_partner_sdk.client import AladdinConnectClient
 import jwt
 import voluptuous as vol
 
 from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
-from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
+from homeassistant.helpers import config_entry_oauth2_flow
 
-from .api import AsyncConfigFlowAuth
 from .const import CONFIG_FLOW_MINOR_VERSION, CONFIG_FLOW_VERSION, DOMAIN
 
 
@@ -54,25 +52,11 @@ class OAuth2FlowHandler(
 
     async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
         """Create an oauth config entry or update existing entry for reauth."""
-        try:
-            token = jwt.decode(
-                data["token"]["access_token"], options={"verify_signature": False}
-            )
-            user_id = token["sub"]
-        except jwt.DecodeError, KeyError:
-            return self.async_abort(reason="oauth_error")
-
-        client = AladdinConnectClient(
-            AsyncConfigFlowAuth(
-                aiohttp_client.async_get_clientsession(self.hass),
-                data["token"]["access_token"],
-            )
+        # Extract the user ID from the JWT token's 'sub' field
+        token = jwt.decode(
+            data["token"]["access_token"], options={"verify_signature": False}
         )
-        try:
-            await client.get_doors()
-        except Exception:  # noqa: BLE001
-            return self.async_abort(reason="cannot_connect")
-
+        user_id = token["sub"]
         await self.async_set_unique_id(user_id)
 
         if self.source == SOURCE_REAUTH:

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -7,31 +7,39 @@ rules:
   brands: done
   common-modules: done
   config-flow: done
-  config-flow-test-coverage: done
+  config-flow-test-coverage: todo
   dependency-transparency: done
   docs-actions:
     status: exempt
     comment: Integration does not register any service actions.
   docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
+  docs-installation-instructions:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-removal-instructions:
+    status: todo
+    comment: Documentation needs to be created.
   entity-event-setup:
     status: exempt
     comment: Integration does not subscribe to external events.
   entity-unique-id: done
   has-entity-name: done
   runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
+  test-before-configure:
+    status: todo
+    comment: Config flow does not currently test connection during setup.
+  test-before-setup: todo
   unique-config-entry: done
 
   # Silver
   action-exceptions: todo
   config-entry-unloading: done
   docs-configuration-parameters:
-    status: exempt
-    comment: Integration does not have an options flow.
-  docs-installation-parameters: done
+    status: todo
+    comment: Documentation needs to be created.
+  docs-installation-parameters:
+    status: todo
+    comment: Documentation needs to be created.
   entity-unavailable: todo
   integration-owner: done
   log-when-unavailable: todo
@@ -44,17 +52,29 @@ rules:
   # Gold
   devices: done
   diagnostics: todo
-  discovery: done
-  discovery-update-info:
-    status: exempt
-    comment: Integration connects via the cloud and not locally.
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: done
+  discovery: todo
+  discovery-update-info: todo
+  docs-data-update:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-examples:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-known-limitations:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-supported-devices:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-supported-functions:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-troubleshooting:
+    status: todo
+    comment: Documentation needs to be created.
+  docs-use-cases:
+    status: todo
+    comment: Documentation needs to be created.
   dynamic-devices: todo
   entity-category: done
   entity-device-class: done
@@ -66,7 +86,7 @@ rules:
   repair-issues: todo
   stale-devices:
     status: todo
-    comment: We can automatically remove removed devices
+    comment: Stale devices can be done dynamically
 
   # Platinum
   async-dependency: todo

homeassistant/components/aladdin_connect/strings.json

@@ -4,7 +4,6 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "cloud_not_enabled": "Please make sure you run Home Assistant with `{default_config}` enabled in your configuration.yaml.",
       "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
       "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",

homeassistant/components/anthropic/config_flow.py

@@ -112,12 +112,19 @@ async def get_model_list(client: anthropic.AsyncAnthropic) -> list[SelectOptionD
         # Resolve alias from versioned model name:
         model_alias = (
             model_info.id[:-9]
-            if model_info.id != "claude-3-haiku-20240307"
+            if model_info.id
+            not in (
+                "claude-3-haiku-20240307",
+                "claude-3-5-haiku-20241022",
+                "claude-3-opus-20240229",
+            )
             and model_info.id[-2:-1] != "-"
             else model_info.id
         )
         if short_form.search(model_alias):
             model_alias += "-0"
+        if model_alias.endswith(("haiku", "opus", "sonnet")):
+            model_alias += "-latest"
         model_options.append(
             SelectOptionDict(
                 label=model_info.display_name,

homeassistant/components/anthropic/const.py

@@ -37,6 +37,8 @@ DEFAULT = {
 MIN_THINKING_BUDGET = 1024
 
 NON_THINKING_MODELS = [
+    "claude-3-5",  # Both sonnet and haiku
+    "claude-3-opus",
     "claude-3-haiku",
 ]
 
@@ -49,7 +51,7 @@ NON_ADAPTIVE_THINKING_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3-haiku",
+    "claude-3",
 ]
 
 UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
@@ -58,13 +60,19 @@ UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3-haiku",
+    "claude-3",
 ]
 
 WEB_SEARCH_UNSUPPORTED_MODELS = [
     "claude-3-haiku",
+    "claude-3-opus",
+    "claude-3-5-sonnet-20240620",
+    "claude-3-5-sonnet-20241022",
 ]
 
 DEPRECATED_MODELS = [
-    "claude-3",
+    "claude-3-5-haiku",
+    "claude-3-7-sonnet",
+    "claude-3-5-sonnet",
+    "claude-3-opus",
 ]

homeassistant/components/anthropic/entity.py

@@ -132,21 +132,11 @@ class ContentDetails:
     """Native data for AssistantContent."""
 
     citation_details: list[CitationDetails] = field(default_factory=list)
-    thinking_signature: str | None = None
-    redacted_thinking: str | None = None
 
     def has_content(self) -> bool:
-        """Check if there is any text content."""
+        """Check if there is any content."""
         return any(detail.length > 0 for detail in self.citation_details)
 
-    def __bool__(self) -> bool:
-        """Check if there is any thinking content or citations."""
-        return (
-            self.thinking_signature is not None
-            or self.redacted_thinking is not None
-            or self.has_citations()
-        )
-
     def has_citations(self) -> bool:
         """Check if there are any citations."""
         return any(detail.citations for detail in self.citation_details)
@@ -256,28 +246,29 @@ def _convert_content(
                         content=[],
                     )
                 )
-            elif isinstance(messages[-1]["content"], str):
-                messages[-1]["content"] = [
-                    TextBlockParam(type="text", text=messages[-1]["content"]),
-                ]
 
-            if isinstance(content.native, ContentDetails):
-                if content.native.thinking_signature:
-                    messages[-1]["content"].append(  # type: ignore[union-attr]
-                        ThinkingBlockParam(
-                            type="thinking",
-                            thinking=content.thinking_content or "",
-                            signature=content.native.thinking_signature,
-                        )
+            if isinstance(content.native, ThinkingBlock):
+                messages[-1]["content"].append(  # type: ignore[union-attr]
+                    ThinkingBlockParam(
+                        type="thinking",
+                        thinking=content.thinking_content or "",
+                        signature=content.native.signature,
                     )
-                if content.native.redacted_thinking:
-                    messages[-1]["content"].append(  # type: ignore[union-attr]
-                        RedactedThinkingBlockParam(
-                            type="redacted_thinking",
-                            data=content.native.redacted_thinking,
-                        )
+                )
+            elif isinstance(content.native, RedactedThinkingBlock):
+                redacted_thinking_block = RedactedThinkingBlockParam(
+                    type="redacted_thinking",
+                    data=content.native.data,
+                )
+                if isinstance(messages[-1]["content"], str):
+                    messages[-1]["content"] = [
+                        TextBlockParam(type="text", text=messages[-1]["content"]),
+                        redacted_thinking_block,
+                    ]
+                else:
+                    messages[-1]["content"].append(  # type: ignore[attr-defined]
+                        redacted_thinking_block
                     )
-
             if content.content:
                 current_index = 0
                 for detail in (
@@ -318,7 +309,6 @@ def _convert_content(
                             text=content.content[current_index:],
                         )
                     )
-
             if content.tool_calls:
                 messages[-1]["content"].extend(  # type: ignore[union-attr]
                     [
@@ -338,14 +328,6 @@ def _convert_content(
                         for tool_call in content.tool_calls
                     ]
                 )
-
-            if (
-                isinstance(messages[-1]["content"], list)
-                and len(messages[-1]["content"]) == 1
-                and messages[-1]["content"][0]["type"] == "text"
-            ):
-                # If there is only one text block, simplify the content to a string
-                messages[-1]["content"] = messages[-1]["content"][0]["text"]
         else:
             # Note: We don't pass SystemContent here as its passed to the API as the prompt
             raise TypeError(f"Unexpected content type: {type(content)}")
@@ -397,7 +379,8 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
     content_details = ContentDetails()
     content_details.add_citation_detail()
     input_usage: Usage | None = None
-    first_block: bool = True
+    has_native = False
+    first_block: bool
 
     async for response in stream:
         LOGGER.debug("Received response: %s", response)
@@ -418,12 +401,13 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 current_tool_args = ""
                 if response.content_block.name == output_tool:
                     if first_block or content_details.has_content():
-                        if content_details:
+                        if content_details.has_citations():
                             content_details.delete_empty()
                             yield {"native": content_details}
                         content_details = ContentDetails()
                         content_details.add_citation_detail()
                         yield {"role": "assistant"}
+                        has_native = False
                         first_block = False
             elif isinstance(response.content_block, TextBlock):
                 if (  # Do not start a new assistant content just for citations, concatenate consecutive blocks with citations instead.
@@ -434,11 +418,12 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                         and content_details.has_content()
                     )
                 ):
-                    if content_details:
+                    if content_details.has_citations():
                         content_details.delete_empty()
                         yield {"native": content_details}
                     content_details = ContentDetails()
                     yield {"role": "assistant"}
+                    has_native = False
                     first_block = False
                 content_details.add_citation_detail()
                 if response.content_block.text:
@@ -447,13 +432,14 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     )
                     yield {"content": response.content_block.text}
             elif isinstance(response.content_block, ThinkingBlock):
-                if first_block or content_details.thinking_signature:
-                    if content_details:
+                if first_block or has_native:
+                    if content_details.has_citations():
                         content_details.delete_empty()
                         yield {"native": content_details}
                     content_details = ContentDetails()
                     content_details.add_citation_detail()
                     yield {"role": "assistant"}
+                    has_native = False
                     first_block = False
             elif isinstance(response.content_block, RedactedThinkingBlock):
                 LOGGER.debug(
@@ -461,15 +447,17 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     "encrypted for safety reasons. This doesn’t affect the quality of "
                     "responses"
                 )
-                if first_block or content_details.redacted_thinking:
-                    if content_details:
+                if has_native:
+                    if content_details.has_citations():
                         content_details.delete_empty()
                         yield {"native": content_details}
                     content_details = ContentDetails()
                     content_details.add_citation_detail()
                     yield {"role": "assistant"}
+                    has_native = False
                     first_block = False
-                content_details.redacted_thinking = response.content_block.data
+                yield {"native": response.content_block}
+                has_native = True
             elif isinstance(response.content_block, ServerToolUseBlock):
                 current_tool_block = ServerToolUseBlockParam(
                     type="server_tool_use",
@@ -479,7 +467,7 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 )
                 current_tool_args = ""
             elif isinstance(response.content_block, WebSearchToolResultBlock):
-                if content_details:
+                if content_details.has_citations():
                     content_details.delete_empty()
                     yield {"native": content_details}
                 content_details = ContentDetails()
@@ -522,16 +510,19 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 else:
                     current_tool_args += response.delta.partial_json
             elif isinstance(response.delta, TextDelta):
-                if response.delta.text:
-                    content_details.citation_details[-1].length += len(
-                        response.delta.text
-                    )
-                    yield {"content": response.delta.text}
+                content_details.citation_details[-1].length += len(response.delta.text)
+                yield {"content": response.delta.text}
             elif isinstance(response.delta, ThinkingDelta):
-                if response.delta.thinking:
-                    yield {"thinking_content": response.delta.thinking}
+                yield {"thinking_content": response.delta.thinking}
             elif isinstance(response.delta, SignatureDelta):
-                content_details.thinking_signature = response.delta.signature
+                yield {
+                    "native": ThinkingBlock(
+                        type="thinking",
+                        thinking="",
+                        signature=response.delta.signature,
+                    )
+                }
+                has_native = True
             elif isinstance(response.delta, CitationsDelta):
                 content_details.add_citation(response.delta.citation)
         elif isinstance(response, RawContentBlockStopEvent):
@@ -558,7 +549,7 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
             if response.delta.stop_reason == "refusal":
                 raise HomeAssistantError("Potential policy violation detected")
         elif isinstance(response, RawMessageStopEvent):
-            if content_details:
+            if content_details.has_citations():
                 content_details.delete_empty()
                 yield {"native": content_details}
             content_details = ContentDetails()

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.83.0"]
+  "requirements": ["anthropic==0.78.0"]
 }

homeassistant/components/anthropic/quality_scale.yaml

@@ -10,7 +10,15 @@ rules:
       Integration does not poll.
   brands: done
   common-modules: done
-  config-flow-test-coverage: done
+  config-flow-test-coverage:
+    status: todo
+    comment: |
+      * Remove integration setup from the config flow init test
+      * Make `mock_setup_entry` a separate fixture
+      * Use the mock_config_entry fixture in `test_duplicate_entry`
+      * `test_duplicate_entry`: Patch `homeassistant.components.anthropic.config_flow.anthropic.resources.models.AsyncModels.list`
+      * Fix docstring and name for `test_form_invalid_auth` (does not only test auth)
+      * In `test_form_invalid_auth`, make sure the test run until CREATE_ENTRY to test that the flow is able to recover
   config-flow: done
   dependency-transparency: done
   docs-actions:

homeassistant/components/anthropic/repairs.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 import voluptuous as vol
 
@@ -19,7 +19,7 @@ from homeassistant.helpers.selector import (
 )
 
 from .config_flow import get_model_list
-from .const import CONF_CHAT_MODEL, DEPRECATED_MODELS, DOMAIN
+from .const import CONF_CHAT_MODEL, DEFAULT, DEPRECATED_MODELS, DOMAIN
 
 if TYPE_CHECKING:
     from . import AnthropicConfigEntry
@@ -67,23 +67,13 @@ class ModelDeprecatedRepairFlow(RepairsFlow):
             self._model_list_cache[entry.entry_id] = model_list
 
         if "opus" in model:
-            family = "claude-opus"
+            suggested_model = "claude-opus-4-5"
+        elif "haiku" in model:
+            suggested_model = "claude-haiku-4-5"
         elif "sonnet" in model:
-            family = "claude-sonnet"
+            suggested_model = "claude-sonnet-4-5"
         else:
-            family = "claude-haiku"
-
-        suggested_model = next(
-            (
-                model_option["value"]
-                for model_option in sorted(
-                    (m for m in model_list if family in m["value"]),
-                    key=lambda x: x["value"],
-                    reverse=True,
-                )
-            ),
-            vol.UNDEFINED,
-        )
+            suggested_model = cast(str, DEFAULT[CONF_CHAT_MODEL])
 
         schema = vol.Schema(
             {

homeassistant/components/backup/util.py

@@ -16,7 +16,6 @@ from typing import IO, Any, cast
 
 import aiohttp
 from securetar import (
-    InvalidPasswordError,
     SecureTarArchive,
     SecureTarError,
     SecureTarFile,
@@ -166,7 +165,7 @@ def validate_password(path: Path, password: str | None) -> bool:
             ):
                 # If we can read the tar file, the password is correct
                 return True
-        except tarfile.ReadError, InvalidPasswordError, SecureTarReadError:
+        except tarfile.ReadError, SecureTarReadError:
             LOGGER.debug("Invalid password")
             return False
         except Exception:  # noqa: BLE001
@@ -193,14 +192,13 @@ def validate_password_stream(
         for obj in input_archive.tar:
             if not obj.name.endswith((".tar", ".tgz", ".tar.gz")):
                 continue
-            try:
-                with input_archive.extract_tar(obj) as decrypted:
-                    if decrypted.plaintext_size is None:
-                        raise UnsupportedSecureTarVersion
+            with input_archive.extract_tar(obj) as decrypted:
+                if decrypted.plaintext_size is None:
+                    raise UnsupportedSecureTarVersion
+                try:
                     decrypted.read(1)  # Read a single byte to trigger the decryption
-            except (InvalidPasswordError, SecureTarReadError) as err:
-                raise IncorrectPassword from err
-            else:
+                except SecureTarReadError as err:
+                    raise IncorrectPassword from err
                 return
     raise BackupEmpty
 

homeassistant/components/bsblan/climate.py

@@ -21,6 +21,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util.enum import try_parse_enum
 
 from . import BSBLanConfigEntry, BSBLanData
 from .const import ATTR_TARGET_TEMPERATURE, DOMAIN
@@ -112,7 +113,7 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         return target_temp.value
 
     @property
-    def _hvac_mode_value(self) -> int | None:
+    def _hvac_mode_value(self) -> int | str | None:
         """Return the raw hvac_mode value from the coordinator."""
         if (hvac_mode := self.coordinator.data.state.hvac_mode) is None:
             return None
@@ -123,14 +124,16 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         """Return hvac operation ie. heat, cool mode."""
         if (hvac_mode_value := self._hvac_mode_value) is None:
             return None
-        return BSBLAN_TO_HA_HVAC_MODE.get(hvac_mode_value)
+        # BSB-Lan returns integer values: 0=off, 1=auto, 2=eco, 3=heat
+        if isinstance(hvac_mode_value, int):
+            return BSBLAN_TO_HA_HVAC_MODE.get(hvac_mode_value)
+        return try_parse_enum(HVACMode, hvac_mode_value)
 
     @property
     def hvac_action(self) -> HVACAction | None:
         """Return the current running hvac action."""
-        if (
-            action := self.coordinator.data.state.hvac_action
-        ) is None or action.value is None:
+        action = self.coordinator.data.state.hvac_action
+        if not action or not isinstance(action.value, int):
             return None
         category = get_hvac_action_category(action.value)
         return HVACAction(category.name.lower())

homeassistant/components/bsblan/coordinator.py

@@ -29,13 +29,8 @@ if TYPE_CHECKING:
 
 # Filter lists for optimized API calls - only fetch parameters we actually use
 # This significantly reduces response time (~0.2s per parameter saved)
-STATE_INCLUDE = [
-    "current_temperature",
-    "target_temperature",
-    "hvac_mode",
-    "hvac_action",
-]
-SENSOR_INCLUDE = ["current_temperature", "outside_temperature", "total_energy"]
+STATE_INCLUDE = ["current_temperature", "target_temperature", "hvac_mode"]
+SENSOR_INCLUDE = ["current_temperature", "outside_temperature"]
 DHW_STATE_INCLUDE = [
     "operating_mode",
     "nominal_setpoint",

homeassistant/components/bsblan/diagnostics.py

@@ -17,24 +17,24 @@ async def async_get_config_entry_diagnostics(
 
     # Build diagnostic data from both coordinators
     diagnostics = {
-        "info": data.info.model_dump(),
-        "device": data.device.model_dump(),
+        "info": data.info.to_dict(),
+        "device": data.device.to_dict(),
         "fast_coordinator_data": {
-            "state": data.fast_coordinator.data.state.model_dump(),
-            "sensor": data.fast_coordinator.data.sensor.model_dump(),
-            "dhw": data.fast_coordinator.data.dhw.model_dump(),
+            "state": data.fast_coordinator.data.state.to_dict(),
+            "sensor": data.fast_coordinator.data.sensor.to_dict(),
+            "dhw": data.fast_coordinator.data.dhw.to_dict(),
         },
-        "static": data.static.model_dump(),
+        "static": data.static.to_dict(),
     }
 
     # Add DHW config and schedule from slow coordinator if available
     if data.slow_coordinator.data:
         slow_data = {}
         if data.slow_coordinator.data.dhw_config:
-            slow_data["dhw_config"] = data.slow_coordinator.data.dhw_config.model_dump()
+            slow_data["dhw_config"] = data.slow_coordinator.data.dhw_config.to_dict()
         if data.slow_coordinator.data.dhw_schedule:
             slow_data["dhw_schedule"] = (
-                data.slow_coordinator.data.dhw_schedule.model_dump()
+                data.slow_coordinator.data.dhw_schedule.to_dict()
             )
         if slow_data:
             diagnostics["slow_coordinator_data"] = slow_data

homeassistant/components/bsblan/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==5.0.1"],
+  "requirements": ["python-bsblan==4.2.1"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bsblan/sensor.py

@@ -11,7 +11,7 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import UnitOfEnergy, UnitOfTemperature
+from homeassistant.const import UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -58,19 +58,6 @@ SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
         ),
         exists_fn=lambda data: data.sensor.outside_temperature is not None,
     ),
-    BSBLanSensorEntityDescription(
-        key="total_energy",
-        translation_key="total_energy",
-        device_class=SensorDeviceClass.ENERGY,
-        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
-        state_class=SensorStateClass.TOTAL_INCREASING,
-        value_fn=lambda data: (
-            data.sensor.total_energy.value
-            if data.sensor.total_energy is not None
-            else None
-        ),
-        exists_fn=lambda data: data.sensor.total_energy is not None,
-    ),
 )
 
 

homeassistant/components/bsblan/strings.json

@@ -66,9 +66,6 @@
       },
       "outside_temperature": {
         "name": "Outside temperature"
-      },
-      "total_energy": {
-        "name": "Total energy"
       }
     }
   },

homeassistant/components/bsblan/water_heater.py

@@ -110,11 +110,12 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
     @property
     def current_operation(self) -> str | None:
         """Return current operation."""
-        if (
-            operating_mode := self.coordinator.data.dhw.operating_mode
-        ) is None or operating_mode.value is None:
+        if (operating_mode := self.coordinator.data.dhw.operating_mode) is None:
             return None
-        return BSBLAN_TO_HA_OPERATION_MODE.get(operating_mode.value)
+        # The operating_mode.value is an integer (0=Off, 1=On, 2=Eco)
+        if isinstance(operating_mode.value, int):
+            return BSBLAN_TO_HA_OPERATION_MODE.get(operating_mode.value)
+        return None
 
     @property
     def current_temperature(self) -> float | None:

homeassistant/components/ecovacs/vacuum.py

@@ -8,24 +8,17 @@ from typing import TYPE_CHECKING, Any
 
 from deebot_client.capabilities import Capabilities, DeviceType
 from deebot_client.device import Device
-from deebot_client.events import (
-    CachedMapInfoEvent,
-    FanSpeedEvent,
-    RoomsEvent,
-    StateEvent,
-)
-from deebot_client.events.map import Map
-from deebot_client.models import CleanAction, CleanMode, State
+from deebot_client.events import FanSpeedEvent, RoomsEvent, StateEvent
+from deebot_client.models import CleanAction, CleanMode, Room, State
 import sucks
 
 from homeassistant.components.vacuum import (
-    Segment,
     StateVacuumEntity,
     StateVacuumEntityDescription,
     VacuumActivity,
     VacuumEntityFeature,
 )
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import slugify
@@ -36,7 +29,6 @@ from .entity import EcovacsEntity, EcovacsLegacyEntity
 from .util import get_name_key
 
 _LOGGER = logging.getLogger(__name__)
-_SEGMENTS_SEPARATOR = "_"
 
 ATTR_ERROR = "error"
 
@@ -226,8 +218,7 @@ class EcovacsVacuum(
         """Initialize the vacuum."""
         super().__init__(device, device.capabilities)
 
-        self._room_event: RoomsEvent | None = None
-        self._maps: dict[str, Map] = {}
+        self._rooms: list[Room] = []
 
         if fan_speed := self._capability.fan_speed:
             self._attr_supported_features |= VacuumEntityFeature.FAN_SPEED
@@ -235,13 +226,14 @@ class EcovacsVacuum(
                 get_name_key(level) for level in fan_speed.types
             ]
 
-        if self._capability.map and self._capability.clean.action.area:
-            self._attr_supported_features |= VacuumEntityFeature.CLEAN_AREA
-
     async def async_added_to_hass(self) -> None:
         """Set up the event listeners now that hass is ready."""
         await super().async_added_to_hass()
 
+        async def on_rooms(event: RoomsEvent) -> None:
+            self._rooms = event.rooms
+            self.async_write_ha_state()
+
         async def on_status(event: StateEvent) -> None:
             self._attr_activity = _STATE_TO_VACUUM_STATE[event.state]
             self.async_write_ha_state()
@@ -257,20 +249,8 @@ class EcovacsVacuum(
             self._subscribe(self._capability.fan_speed.event, on_fan_speed)
 
         if map_caps := self._capability.map:
-
-            async def on_rooms(event: RoomsEvent) -> None:
-                self._room_event = event
-                self._check_segments_changed()
-                self.async_write_ha_state()
-
             self._subscribe(map_caps.rooms.event, on_rooms)
 
-            async def on_map_info(event: CachedMapInfoEvent) -> None:
-                self._maps = {map_obj.id: map_obj for map_obj in event.maps}
-                self._check_segments_changed()
-
-            self._subscribe(map_caps.cached_info.event, on_map_info)
-
     @property
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes.
@@ -279,10 +259,7 @@ class EcovacsVacuum(
         is lowercase snake_case.
         """
         rooms: dict[str, Any] = {}
-        if self._room_event is None:
-            return rooms
-
-        for room in self._room_event.rooms:
+        for room in self._rooms:
             # convert room name to snake_case to meet the convention
             room_name = slugify(room.name)
             room_values = rooms.get(room_name)
@@ -397,116 +374,3 @@ class EcovacsVacuum(
             )
 
         return await self._device.execute_command(position_commands[0])
-
-    @callback
-    def _check_segments_changed(self) -> None:
-        """Check if segments have changed and create repair issue."""
-        last_seen = self.last_seen_segments
-        if last_seen is None:
-            return
-
-        last_seen_ids = {seg.id for seg in last_seen}
-        current_ids = {seg.id for seg in self._get_segments()}
-
-        if current_ids != last_seen_ids:
-            self.async_create_segments_issue()
-
-    def _get_segments(self) -> list[Segment]:
-        """Get the segments that can be cleaned."""
-        last_seen = self.last_seen_segments or []
-        if self._room_event is None or not self._maps:
-            # If we don't have the necessary information to determine segments, return the last
-            # seen segments to avoid temporarily losing all segments until we get the necessary
-            # information, which could cause unnecessary issues to be created
-            return last_seen
-
-        map_id = self._room_event.map_id
-        if (map_obj := self._maps.get(map_id)) is None:
-            _LOGGER.warning("Map ID %s not found in available maps", map_id)
-            return []
-
-        id_prefix = f"{map_id}{_SEGMENTS_SEPARATOR}"
-        other_map_ids = {
-            map_obj.id
-            for map_obj in self._maps.values()
-            if map_obj.id != self._room_event.map_id
-        }
-        # Include segments from the current map and any segments from other maps that were
-        # previously seen, as we want to continue showing segments from other maps for
-        # mapping purposes
-        segments = [
-            seg for seg in last_seen if _split_composite_id(seg.id)[0] in other_map_ids
-        ]
-        segments.extend(
-            Segment(
-                id=f"{id_prefix}{room.id}",
-                name=room.name,
-                group=map_obj.name,
-            )
-            for room in self._room_event.rooms
-        )
-        return segments
-
-    async def async_get_segments(self) -> list[Segment]:
-        """Get the segments that can be cleaned."""
-        return self._get_segments()
-
-    async def async_clean_segments(self, segment_ids: list[str], **kwargs: Any) -> None:
-        """Perform an area clean.
-
-        Only cleans segments from the currently selected map.
-        """
-        if not self._maps:
-            _LOGGER.warning("No map information available, cannot clean segments")
-            return
-
-        valid_room_ids: list[int | float] = []
-        for composite_id in segment_ids:
-            map_id, segment_id = _split_composite_id(composite_id)
-            if (map_obj := self._maps.get(map_id)) is None:
-                _LOGGER.warning("Map ID %s not found in available maps", map_id)
-                continue
-
-            if not map_obj.using:
-                room_name = next(
-                    (
-                        segment.name
-                        for segment in self.last_seen_segments or []
-                        if segment.id == composite_id
-                    ),
-                    "",
-                )
-                _LOGGER.warning(
-                    'Map "%s" is not currently selected, skipping segment "%s" (%s)',
-                    map_obj.name,
-                    room_name,
-                    segment_id,
-                )
-                continue
-
-            valid_room_ids.append(int(segment_id))
-
-        if not valid_room_ids:
-            _LOGGER.warning(
-                "No valid segments to clean after validation, skipping clean segments command"
-            )
-            return
-
-        if TYPE_CHECKING:
-            # Supported feature is only added if clean.action.area is not None
-            assert self._capability.clean.action.area is not None
-
-        await self._device.execute_command(
-            self._capability.clean.action.area(
-                CleanMode.SPOT_AREA,
-                valid_room_ids,
-                1,
-            )
-        )
-
-
-@callback
-def _split_composite_id(composite_id: str) -> tuple[str, str]:
-    """Split a composite ID into its components."""
-    map_id, _, segment_id = composite_id.partition(_SEGMENTS_SEPARATOR)
-    return map_id, segment_id

homeassistant/components/enocean/config_flow.py

@@ -4,23 +4,17 @@ from typing import Any
 
 import voluptuous as vol
 
-from homeassistant.components import usb
-from homeassistant.components.usb import (
-    human_readable_device_name,
-    usb_unique_id_from_service_info,
-)
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import ATTR_MANUFACTURER, CONF_DEVICE, CONF_NAME
+from homeassistant.const import CONF_DEVICE
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.selector import (
     SelectSelector,
     SelectSelectorConfig,
     SelectSelectorMode,
 )
-from homeassistant.helpers.service_info.usb import UsbServiceInfo
 
 from . import dongle
-from .const import DOMAIN, ERROR_INVALID_DONGLE_PATH, LOGGER, MANUFACTURER
+from .const import DOMAIN, ERROR_INVALID_DONGLE_PATH, LOGGER
 
 MANUAL_SCHEMA = vol.Schema(
     {
@@ -37,48 +31,8 @@ class EnOceanFlowHandler(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the EnOcean config flow."""
-        self.data: dict[str, Any] = {}
-
-    async def async_step_usb(self, discovery_info: UsbServiceInfo) -> ConfigFlowResult:
-        """Handle usb discovery."""
-        unique_id = usb_unique_id_from_service_info(discovery_info)
-
-        await self.async_set_unique_id(unique_id)
-        self._abort_if_unique_id_configured(
-            updates={CONF_DEVICE: discovery_info.device}
-        )
-
-        discovery_info.device = await self.hass.async_add_executor_job(
-            usb.get_serial_by_id, discovery_info.device
-        )
-
-        self.data[CONF_DEVICE] = discovery_info.device
-        self.context["title_placeholders"] = {
-            CONF_NAME: human_readable_device_name(
-                discovery_info.device,
-                discovery_info.serial_number,
-                discovery_info.manufacturer,
-                discovery_info.description,
-                discovery_info.vid,
-                discovery_info.pid,
-            )
-        }
-        return await self.async_step_usb_confirm()
-
-    async def async_step_usb_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle USB Discovery confirmation."""
-        if user_input is not None:
-            return await self.async_step_manual({CONF_DEVICE: self.data[CONF_DEVICE]})
-        self._set_confirm_only()
-        return self.async_show_form(
-            step_id="usb_confirm",
-            description_placeholders={
-                ATTR_MANUFACTURER: MANUFACTURER,
-                CONF_DEVICE: self.data.get(CONF_DEVICE, ""),
-            },
-        )
+        self.dongle_path = None
+        self.discovery_info = None
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Import a yaml configuration."""
@@ -150,4 +104,4 @@ class EnOceanFlowHandler(ConfigFlow, domain=DOMAIN):
 
     def create_enocean_entry(self, user_input):
         """Create an entry for the provided configuration."""
-        return self.async_create_entry(title=MANUFACTURER, data=user_input)
+        return self.async_create_entry(title="EnOcean", data=user_input)

homeassistant/components/enocean/const.py

@@ -6,8 +6,6 @@ from homeassistant.const import Platform
 
 DOMAIN = "enocean"
 
-MANUFACTURER = "EnOcean"
-
 ERROR_INVALID_DONGLE_PATH = "invalid_dongle_path"
 
 SIGNAL_RECEIVE_MESSAGE = "enocean.receive_message"

homeassistant/components/enocean/manifest.json

@@ -3,19 +3,10 @@
   "name": "EnOcean",
   "codeowners": [],
   "config_flow": true,
-  "dependencies": ["usb"],
   "documentation": "https://www.home-assistant.io/integrations/enocean",
-  "integration_type": "hub",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["enocean"],
   "requirements": ["enocean==0.50"],
-  "single_config_entry": true,
-  "usb": [
-    {
-      "description": "*usb 300*",
-      "manufacturer": "*enocean*",
-      "pid": "6001",
-      "vid": "0403"
-    }
-  ]
+  "single_config_entry": true
 }

homeassistant/components/enocean/strings.json

@@ -25,9 +25,6 @@
           "device": "[%key:component::enocean::config::step::detect::data_description::device%]"
         },
         "description": "Enter the path to your EnOcean USB dongle."
-      },
-      "usb_confirm": {
-        "description": "{manufacturer} USB dongle detected at {device}. Do you want to set up this device?"
       }
     }
   },

homeassistant/components/esphome/entry_data.py

@@ -300,23 +300,16 @@ class RuntimeEntryData:
                 needed_platforms.add(Platform.BINARY_SENSOR)
                 needed_platforms.add(Platform.SELECT)
 
+        needed_platforms.update(INFO_TYPE_TO_PLATFORM[type(info)] for info in infos)
+        await self._ensure_platforms_loaded(hass, entry, needed_platforms)
+
         # Make a dict of the EntityInfo by type and send
         # them to the listeners for each specific EntityInfo type
-        info_types_to_platform = INFO_TYPE_TO_PLATFORM
         infos_by_type: defaultdict[type[EntityInfo], list[EntityInfo]] = defaultdict(
             list
         )
         for info in infos:
-            info_type = type(info)
-            if platform := info_types_to_platform.get(info_type):
-                needed_platforms.add(platform)
-                infos_by_type[info_type].append(info)
-            else:
-                _LOGGER.warning(
-                    "Entity type %s is not supported in this version of Home Assistant",
-                    info_type,
-                )
-        await self._ensure_platforms_loaded(hass, entry, needed_platforms)
+            infos_by_type[type(info)].append(info)
 
         for type_, callbacks in self.entity_info_callbacks.items():
             # If all entities for a type are removed, we

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==44.1.0",
+    "aioesphomeapi==44.0.0",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==3.6.0"
   ],

homeassistant/components/fritzbox_callmonitor/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "fritzbox_callmonitor",
   "name": "FRITZ!Box Call Monitor",
-  "codeowners": [],
+  "codeowners": ["@cdce8p"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/fritzbox_callmonitor",
   "integration_type": "device",

homeassistant/components/google_assistant/trait.py

@@ -1752,15 +1752,15 @@ class FanSpeedTrait(_Trait):
         """Initialize a trait for a state."""
         super().__init__(hass, state, config)
         if state.domain == fan.DOMAIN:
-            speed_count = round(
-                100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
+            speed_count = min(
+                FAN_SPEED_MAX_SPEED_COUNT,
+                round(
+                    100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
+                ),
             )
-            if speed_count <= FAN_SPEED_MAX_SPEED_COUNT:
-                self._ordered_speed = [
-                    f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
-                ]
-            else:
-                self._ordered_speed = []
+            self._ordered_speed = [
+                f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
+            ]
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -1786,11 +1786,7 @@ class FanSpeedTrait(_Trait):
             result.update(
                 {
                     "reversible": reversible,
-                    # supportsFanSpeedPercent is mutually exclusive with
-                    # availableFanSpeeds, where supportsFanSpeedPercent takes
-                    # precedence. Report it only when step speeds are not
-                    # supported so Google renders a percent slider (1-100%).
-                    "supportsFanSpeedPercent": not self._ordered_speed,
+                    "supportsFanSpeedPercent": True,
                 }
             )
 
@@ -1836,12 +1832,10 @@ class FanSpeedTrait(_Trait):
 
         if domain == fan.DOMAIN:
             percent = attrs.get(fan.ATTR_PERCENTAGE) or 0
-            if self._ordered_speed:
-                response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
-                    self._ordered_speed, percent
-                )
-            else:
-                response["currentFanSpeedPercent"] = percent
+            response["currentFanSpeedPercent"] = percent
+            response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
+                self._ordered_speed, percent
+            )
 
         return response
 
@@ -1861,7 +1855,7 @@ class FanSpeedTrait(_Trait):
             )
 
         if domain == fan.DOMAIN:
-            if self._ordered_speed and (fan_speed := params.get("fanSpeed")):
+            if fan_speed := params.get("fanSpeed"):
                 fan_speed_percent = ordered_list_item_to_percentage(
                     self._ordered_speed, fan_speed
                 )

homeassistant/components/google_translate/strings.json

@@ -11,10 +11,5 @@
         }
       }
     }
-  },
-  "device": {
-    "google_translate": {
-      "name": "Google Translate {lang} {tld}"
-    }
   }
 }

homeassistant/components/google_translate/tts.py

@@ -19,7 +19,6 @@ from homeassistant.components.tts import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
@@ -27,7 +26,6 @@ from .const import (
     CONF_TLD,
     DEFAULT_LANG,
     DEFAULT_TLD,
-    DOMAIN,
     MAP_LANG_TLD,
     SUPPORT_LANGUAGES,
     SUPPORT_TLD,
@@ -68,9 +66,6 @@ async def async_setup_entry(
 class GoogleTTSEntity(TextToSpeechEntity):
     """The Google speech API entity."""
 
-    _attr_supported_languages = SUPPORT_LANGUAGES
-    _attr_supported_options = SUPPORT_OPTIONS
-
     def __init__(self, config_entry: ConfigEntry, lang: str, tld: str) -> None:
         """Init Google TTS service."""
         if lang in MAP_LANG_TLD:
@@ -82,15 +77,20 @@ class GoogleTTSEntity(TextToSpeechEntity):
         self._attr_name = f"Google Translate {self._lang} {self._tld}"
         self._attr_unique_id = config_entry.entry_id
 
-        self._attr_device_info = DeviceInfo(
-            entry_type=DeviceEntryType.SERVICE,
-            identifiers={(DOMAIN, config_entry.entry_id)},
-            manufacturer="Google",
-            model="Google Translate TTS",
-            translation_key="google_translate",
-            translation_placeholders={"lang": self._lang, "tld": self._tld},
-        )
-        self._attr_default_language = self._lang
+    @property
+    def default_language(self) -> str:
+        """Return the default language."""
+        return self._lang
+
+    @property
+    def supported_languages(self) -> list[str]:
+        """Return list of supported languages."""
+        return SUPPORT_LANGUAGES
+
+    @property
+    def supported_options(self) -> list[str]:
+        """Return a list of supported options."""
+        return SUPPORT_OPTIONS
 
     def get_tts_audio(
         self, message: str, language: str, options: dict[str, Any] | None = None

homeassistant/components/hassio/ingress.py

@@ -181,7 +181,8 @@ class HassIOIngress(HomeAssistantView):
             skip_auto_headers={hdrs.CONTENT_TYPE},
         ) as result:
             headers = _response_header(result)
-
+            content_length_int = 0
+            content_length = result.headers.get(hdrs.CONTENT_LENGTH, UNDEFINED)
             # Avoid parsing content_type in simple cases for better performance
             if maybe_content_type := result.headers.get(hdrs.CONTENT_TYPE):
                 content_type: str = (maybe_content_type.partition(";"))[0].strip()
@@ -189,30 +190,17 @@ class HassIOIngress(HomeAssistantView):
                 # default value according to RFC 2616
                 content_type = "application/octet-stream"
 
-            # Empty body responses (304, 204, HEAD, etc.) should not be streamed,
-            # otherwise aiohttp < 3.9.0 may generate an invalid "0\r\n\r\n" chunk
-            # This also avoids setting content_type for empty responses.
-            if must_be_empty_body(request.method, result.status):
-                # If upstream contains content-type, preserve it (e.g. for HEAD requests)
-                # Note: This still is omitting content-length. We can't simply forward
-                # the upstream length since the proxy might change the body length
-                # (e.g. due to compression).
-                if maybe_content_type:
-                    headers[hdrs.CONTENT_TYPE] = content_type
-                return web.Response(
-                    headers=headers,
-                    status=result.status,
-                )
-
             # Simple request
-            content_length_int = 0
-            content_length = result.headers.get(hdrs.CONTENT_LENGTH, UNDEFINED)
-            if (
+            if (empty_body := must_be_empty_body(result.method, result.status)) or (
                 content_length is not UNDEFINED
                 and (content_length_int := int(content_length))
                 <= MAX_SIMPLE_RESPONSE_SIZE
             ):
-                body = await result.read()
+                # Return Response
+                if empty_body:
+                    body = None
+                else:
+                    body = await result.read()
                 simple_response = web.Response(
                     headers=headers,
                     status=result.status,

homeassistant/components/hikvision/manifest.json

@@ -7,5 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyhik"],
+  "quality_scale": "legacy",
   "requirements": ["pyHik==0.4.2"]
 }

homeassistant/components/hikvision/quality_scale.yaml

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

homeassistant/components/homee/config_flow.py

@@ -11,12 +11,7 @@ from pyHomee import (
 )
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    SOURCE_USER,
-    ConfigEntryState,
-    ConfigFlow,
-    ConfigFlowResult,
-)
+from homeassistant.config_entries import SOURCE_USER, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
@@ -118,22 +113,7 @@ class HomeeConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery_info.ip_address.version == 6:
             return self.async_abort(reason="ipv6_address")
 
-        # If an already configured homee reports with a second IP, abort.
-        existing_entry = await self.async_set_unique_id(self._name)
-        if (
-            existing_entry
-            and existing_entry.state == ConfigEntryState.LOADED
-            and existing_entry.runtime_data.connected
-            and existing_entry.data[CONF_HOST] != self._host
-        ):
-            _LOGGER.debug(
-                "Aborting config flow for discovered homee with IP %s "
-                "since it is already configured at IP %s",
-                self._host,
-                existing_entry.data[CONF_HOST],
-            )
-            return self.async_abort(reason="2nd_ip_address")
-
+        await self.async_set_unique_id(self._name)
         self._abort_if_unique_id_configured(updates={CONF_HOST: self._host})
 
         # Cause an auth-error to see if homee is reachable.

homeassistant/components/homee/event.py

@@ -20,7 +20,6 @@ PARALLEL_UPDATES = 0
 
 REMOTE_PROFILES = [
     NodeProfile.REMOTE,
-    NodeProfile.ONE_BUTTON_REMOTE,
     NodeProfile.TWO_BUTTON_REMOTE,
     NodeProfile.THREE_BUTTON_REMOTE,
     NodeProfile.FOUR_BUTTON_REMOTE,

homeassistant/components/homee/strings.json

@@ -1,7 +1,6 @@
 {
   "config": {
     "abort": {
-      "2nd_ip_address": "Your homee is already connected using another IP address",
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",

homeassistant/components/homevolt/__init__.py

@@ -10,7 +10,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .coordinator import HomevoltConfigEntry, HomevoltDataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [Platform.SENSOR, Platform.SWITCH]
+PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: HomevoltConfigEntry) -> bool:

homeassistant/components/homevolt/entity.py

@@ -1,67 +0,0 @@
-"""Shared entity helpers for Homevolt."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Coroutine
-from typing import Any, Concatenate
-
-from homevolt import HomevoltAuthenticationError, HomevoltConnectionError, HomevoltError
-
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN, MANUFACTURER
-from .coordinator import HomevoltDataUpdateCoordinator
-
-
-class HomevoltEntity(CoordinatorEntity[HomevoltDataUpdateCoordinator]):
-    """Base Homevolt entity."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self, coordinator: HomevoltDataUpdateCoordinator, device_identifier: str
-    ) -> None:
-        """Initialize the Homevolt entity."""
-        super().__init__(coordinator)
-        device_id = coordinator.data.unique_id
-        device_metadata = coordinator.data.device_metadata.get(device_identifier)
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, f"{device_id}_{device_identifier}")},
-            configuration_url=coordinator.client.base_url,
-            manufacturer=MANUFACTURER,
-            model=device_metadata.model if device_metadata else None,
-            name=device_metadata.name if device_metadata else None,
-        )
-
-
-def homevolt_exception_handler[_HomevoltEntityT: HomevoltEntity, **_P](
-    func: Callable[Concatenate[_HomevoltEntityT, _P], Coroutine[Any, Any, Any]],
-) -> Callable[Concatenate[_HomevoltEntityT, _P], Coroutine[Any, Any, None]]:
-    """Decorate Homevolt calls to handle exceptions."""
-
-    async def handler(
-        self: _HomevoltEntityT, *args: _P.args, **kwargs: _P.kwargs
-    ) -> None:
-        try:
-            await func(self, *args, **kwargs)
-        except HomevoltAuthenticationError as error:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="auth_failed",
-            ) from error
-        except HomevoltConnectionError as error:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="communication_error",
-                translation_placeholders={"error": str(error)},
-            ) from error
-        except HomevoltError as error:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="unknown_error",
-                translation_placeholders={"error": str(error)},
-            ) from error
-
-    return handler

homeassistant/components/homevolt/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["homevolt==0.5.0"],
+  "requirements": ["homevolt==0.4.4"],
   "zeroconf": [
     {
       "name": "homevolt*",

homeassistant/components/homevolt/sensor.py

@@ -22,11 +22,13 @@ from homeassistant.const import (
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
+from .const import DOMAIN, MANUFACTURER
 from .coordinator import HomevoltConfigEntry, HomevoltDataUpdateCoordinator
-from .entity import HomevoltEntity
 
 PARALLEL_UPDATES = 0  # Coordinator-based updates
 
@@ -307,10 +309,11 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class HomevoltSensor(HomevoltEntity, SensorEntity):
+class HomevoltSensor(CoordinatorEntity[HomevoltDataUpdateCoordinator], SensorEntity):
     """Representation of a Homevolt sensor."""
 
     entity_description: SensorEntityDescription
+    _attr_has_entity_name = True
 
     def __init__(
         self,
@@ -319,12 +322,24 @@ class HomevoltSensor(HomevoltEntity, SensorEntity):
         sensor_key: str,
     ) -> None:
         """Initialize the sensor."""
-        sensor_data = coordinator.data.sensors[sensor_key]
-        super().__init__(coordinator, sensor_data.device_identifier)
+        super().__init__(coordinator)
         self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.unique_id}_{sensor_key}"
+        unique_id = coordinator.data.unique_id
+        self._attr_unique_id = f"{unique_id}_{sensor_key}"
+        sensor_data = coordinator.data.sensors[sensor_key]
         self._sensor_key = sensor_key
 
+        device_metadata = coordinator.data.device_metadata.get(
+            sensor_data.device_identifier
+        )
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, f"{unique_id}_{sensor_data.device_identifier}")},
+            configuration_url=coordinator.client.base_url,
+            manufacturer=MANUFACTURER,
+            model=device_metadata.model if device_metadata else None,
+            name=device_metadata.name if device_metadata else None,
+        )
+
     @property
     def available(self) -> bool:
         """Return if entity is available."""

homeassistant/components/homevolt/strings.json

@@ -160,22 +160,6 @@
       "tmin": {
         "name": "Minimum temperature"
       }
-    },
-    "switch": {
-      "local_mode": {
-        "name": "Local mode"
-      }
-    }
-  },
-  "exceptions": {
-    "auth_failed": {
-      "message": "[%key:common::config_flow::error::invalid_auth%]"
-    },
-    "communication_error": {
-      "message": "[%key:common::config_flow::error::cannot_connect%]"
-    },
-    "unknown_error": {
-      "message": "[%key:common::config_flow::error::unknown%]"
     }
   }
 }

homeassistant/components/homevolt/switch.py

@@ -1,55 +0,0 @@
-"""Support for Homevolt switch entities."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.switch import SwitchEntity
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import HomevoltConfigEntry, HomevoltDataUpdateCoordinator
-from .entity import HomevoltEntity, homevolt_exception_handler
-
-PARALLEL_UPDATES = 0  # Coordinator-based updates
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: HomevoltConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Homevolt switch entities."""
-    coordinator = entry.runtime_data
-    async_add_entities([HomevoltLocalModeSwitch(coordinator)])
-
-
-class HomevoltLocalModeSwitch(HomevoltEntity, SwitchEntity):
-    """Switch entity for Homevolt local mode."""
-
-    _attr_entity_category = EntityCategory.CONFIG
-    _attr_translation_key = "local_mode"
-
-    def __init__(self, coordinator: HomevoltDataUpdateCoordinator) -> None:
-        """Initialize the switch entity."""
-        self._attr_unique_id = f"{coordinator.data.unique_id}_local_mode"
-        device_id = coordinator.data.unique_id
-        super().__init__(coordinator, f"ems_{device_id}")
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if local mode is enabled."""
-        return self.coordinator.client.local_mode_enabled
-
-    @homevolt_exception_handler
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Enable local mode."""
-        await self.coordinator.client.enable_local_mode()
-        await self.coordinator.async_request_refresh()
-
-    @homevolt_exception_handler
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Disable local mode."""
-        await self.coordinator.client.disable_local_mode()
-        await self.coordinator.async_request_refresh()

homeassistant/components/hue_ble/config_flow.py

@@ -6,7 +6,6 @@ from enum import Enum
 import logging
 from typing import Any
 
-from bleak.backends.scanner import AdvertisementData
 from HueBLE import ConnectionError, HueBleError, HueBleLight, PairingError
 import voluptuous as vol
 
@@ -27,17 +26,6 @@ from .light import get_available_color_modes
 _LOGGER = logging.getLogger(__name__)
 
 
-SERVICE_UUID = SERVICE_DATA_UUID = "0000fe0f-0000-1000-8000-00805f9b34fb"
-
-
-def device_filter(advertisement_data: AdvertisementData) -> bool:
-    """Return True if the device is supported."""
-    return (
-        SERVICE_UUID in advertisement_data.service_uuids
-        and SERVICE_DATA_UUID in advertisement_data.service_data
-    )
-
-
 async def validate_input(hass: HomeAssistant, address: str) -> Error | None:
     """Return error if cannot connect and validate."""
 
@@ -82,66 +70,28 @@ class HueBleConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the config flow."""
-        self._discovered_devices: dict[str, bluetooth.BluetoothServiceInfoBleak] = {}
         self._discovery_info: bluetooth.BluetoothServiceInfoBleak | None = None
 
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the user step to pick discovered device."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            unique_id = dr.format_mac(user_input[CONF_MAC])
-            # Don't raise on progress because there may be discovery flows
-            await self.async_set_unique_id(unique_id, raise_on_progress=False)
-            # Guard against the user selecting a device which has been configured by
-            # another flow.
-            self._abort_if_unique_id_configured()
-            self._discovery_info = self._discovered_devices[user_input[CONF_MAC]]
-            return await self.async_step_confirm()
-
-        current_addresses = self._async_current_ids(include_ignore=False)
-        for discovery in bluetooth.async_discovered_service_info(self.hass):
-            if (
-                discovery.address in current_addresses
-                or discovery.address in self._discovered_devices
-                or not device_filter(discovery.advertisement)
-            ):
-                continue
-            self._discovered_devices[discovery.address] = discovery
-
-        if not self._discovered_devices:
-            return self.async_abort(reason="no_devices_found")
-
-        data_schema = vol.Schema(
-            {
-                vol.Required(CONF_MAC): vol.In(
-                    {
-                        service_info.address: (
-                            f"{service_info.name} ({service_info.address})"
-                        )
-                        for service_info in self._discovered_devices.values()
-                    }
-                ),
-            }
-        )
-        return self.async_show_form(
-            step_id="user",
-            data_schema=data_schema,
-            errors=errors,
-        )
-
     async def async_step_bluetooth(
         self, discovery_info: bluetooth.BluetoothServiceInfoBleak
     ) -> ConfigFlowResult:
         """Handle a flow initialized by the home assistant scanner."""
 
         _LOGGER.debug(
-            "HA found light %s. Use user flow to show in UI and connect",
+            "HA found light %s. Will show in UI but not auto connect",
             discovery_info.name,
         )
-        return self.async_abort(reason="discovery_unsupported")
+
+        unique_id = dr.format_mac(discovery_info.address)
+        await self.async_set_unique_id(unique_id)
+        self._abort_if_unique_id_configured()
+
+        name = f"{discovery_info.name} ({discovery_info.address})"
+        self.context.update({"title_placeholders": {CONF_NAME: name}})
+
+        self._discovery_info = discovery_info
+
+        return await self.async_step_confirm()
 
     async def async_step_confirm(
         self, user_input: dict[str, Any] | None = None
@@ -153,10 +103,7 @@ class HueBleConfigFlow(ConfigFlow, domain=DOMAIN):
 
         if user_input is not None:
             unique_id = dr.format_mac(self._discovery_info.address)
-            # Don't raise on progress because there may be discovery flows
-            await self.async_set_unique_id(unique_id, raise_on_progress=False)
-            # Guard against the user selecting a device which has been configured by
-            # another flow.
+            await self.async_set_unique_id(unique_id)
             self._abort_if_unique_id_configured()
             error = await validate_input(self.hass, unique_id)
             if error:

homeassistant/components/hue_ble/strings.json

@@ -2,8 +2,7 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "discovery_unsupported": "Discovery flow is not supported by the Hue BLE integration.",
-      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
+      "not_implemented": "This integration can only be set up via discovery."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -15,16 +14,7 @@
     },
     "step": {
       "confirm": {
-        "description": "Do you want to set up {name} ({mac})?\nMake sure the light is [made discoverable to voice assistants]({url_pairing_mode}) or has been [factory reset]({url_factory_reset})."
-      },
-      "user": {
-        "data": {
-          "mac": "[%key:common::config_flow::data::device%]"
-        },
-        "data_description": {
-          "mac": "Select the Hue device you want to set up"
-        },
-        "description": "[%key:component::bluetooth::config::step::user::description%]"
+        "description": "Do you want to set up {name} ({mac})?. Make sure the light is [made discoverable to voice assistants]({url_pairing_mode}) or has been [factory reset]({url_factory_reset})."
       }
     }
   }

homeassistant/components/intelliclima/__init__.py

@@ -9,7 +9,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from .const import LOGGER
 from .coordinator import IntelliClimaConfigEntry, IntelliClimaCoordinator
 
-PLATFORMS = [Platform.FAN, Platform.SELECT]
+PLATFORMS = [Platform.FAN]
 
 
 async def async_setup_entry(

homeassistant/components/intelliclima/entity.py

@@ -27,6 +27,8 @@ class IntelliClimaEntity(CoordinatorEntity[IntelliClimaCoordinator]):
         """Class initializer."""
         super().__init__(coordinator=coordinator)
 
+        self._attr_unique_id = device.id
+
         # Make this HA "device" use the IntelliClima device name.
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, device.id)},

homeassistant/components/intelliclima/fan.py

@@ -62,7 +62,6 @@ class IntelliClimaVMCFan(IntelliClimaECOEntity, FanEntity):
         super().__init__(coordinator, device)
 
         self._speed_range = (int(FanSpeed.sleep), int(FanSpeed.high))
-        self._attr_unique_id = device.id
 
     @property
     def is_on(self) -> bool:

homeassistant/components/intelliclima/quality_scale.yaml

@@ -49,7 +49,7 @@ rules:
     comment: |
       Unclear if discovery is possible.
   docs-data-update: done
-  docs-examples: done
+  docs-examples: todo
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done

homeassistant/components/intelliclima/select.py

@@ -1,96 +0,0 @@
-"""Select platform for IntelliClima VMC."""
-
-from pyintelliclima.const import FanMode, FanSpeed
-from pyintelliclima.intelliclima_types import IntelliClimaECO
-
-from homeassistant.components.select import SelectEntity
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import IntelliClimaConfigEntry, IntelliClimaCoordinator
-from .entity import IntelliClimaECOEntity
-
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
-
-
-FAN_MODE_TO_INTELLICLIMA_MODE = {
-    "forward": FanMode.inward,
-    "reverse": FanMode.outward,
-    "alternate": FanMode.alternate,
-    "sensor": FanMode.sensor,
-}
-INTELLICLIMA_MODE_TO_FAN_MODE = {v: k for k, v in FAN_MODE_TO_INTELLICLIMA_MODE.items()}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: IntelliClimaConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up IntelliClima VMC fan mode select."""
-    coordinator = entry.runtime_data
-
-    entities: list[IntelliClimaVMCFanModeSelect] = [
-        IntelliClimaVMCFanModeSelect(
-            coordinator=coordinator,
-            device=ecocomfort2,
-        )
-        for ecocomfort2 in coordinator.data.ecocomfort2_devices.values()
-    ]
-
-    async_add_entities(entities)
-
-
-class IntelliClimaVMCFanModeSelect(IntelliClimaECOEntity, SelectEntity):
-    """Representation of an IntelliClima VMC fan mode selector."""
-
-    _attr_translation_key = "fan_mode"
-    _attr_options = ["forward", "reverse", "alternate", "sensor"]
-
-    def __init__(
-        self,
-        coordinator: IntelliClimaCoordinator,
-        device: IntelliClimaECO,
-    ) -> None:
-        """Class initializer."""
-        super().__init__(coordinator, device)
-
-        self._attr_unique_id = f"{device.id}_fan_mode"
-
-    @property
-    def current_option(self) -> str | None:
-        """Return the current fan mode."""
-        device_data = self._device_data
-
-        if device_data.mode_set == FanMode.off:
-            return None
-
-        # If in auto mode (sensor mode with auto speed), return None (handled by fan entity preset mode)
-        if (
-            device_data.speed_set == FanSpeed.auto
-            and device_data.mode_set == FanMode.sensor
-        ):
-            return None
-
-        return INTELLICLIMA_MODE_TO_FAN_MODE.get(FanMode(device_data.mode_set))
-
-    async def async_select_option(self, option: str) -> None:
-        """Set the fan mode."""
-        device_data = self._device_data
-
-        mode = FAN_MODE_TO_INTELLICLIMA_MODE[option]
-
-        # Determine speed: keep current speed if available, otherwise default to sleep
-        if (
-            device_data.speed_set == FanSpeed.auto
-            or device_data.mode_set == FanMode.off
-        ):
-            speed = FanSpeed.sleep
-        else:
-            speed = device_data.speed_set
-
-        await self.coordinator.api.ecocomfort.set_mode_speed(
-            self._device_sn, mode, speed
-        )
-        await self.coordinator.async_request_refresh()

homeassistant/components/intelliclima/strings.json

@@ -22,18 +22,5 @@
         "description": "Authenticate against IntelliClima cloud"
       }
     }
-  },
-  "entity": {
-    "select": {
-      "fan_mode": {
-        "name": "Fan direction mode",
-        "state": {
-          "alternate": "Alternating",
-          "forward": "Forward",
-          "reverse": "Reverse",
-          "sensor": "Sensor"
-        }
-      }
-    }
   }
 }

homeassistant/components/kaleidescape/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/kaleidescape",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["pykaleidescape==1.1.3"],
+  "requirements": ["pykaleidescape==1.1.1"],
   "ssdp": [
     {
       "deviceType": "schemas-upnp-org:device:Basic:1",

homeassistant/components/liebherr/__init__.py

@@ -1,4 +1,4 @@
-"""The Liebherr integration."""
+"""The liebherr integration."""
 
 from __future__ import annotations
 
@@ -17,12 +17,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
 
-PLATFORMS: list[Platform] = [
-    Platform.NUMBER,
-    Platform.SELECT,
-    Platform.SENSOR,
-    Platform.SWITCH,
-]
+PLATFORMS: list[Platform] = [Platform.NUMBER, Platform.SENSOR, Platform.SWITCH]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) -> bool:

homeassistant/components/liebherr/icons.json

@@ -1,55 +1,5 @@
 {
   "entity": {
-    "select": {
-      "bio_fresh_plus": {
-        "default": "mdi:leaf"
-      },
-      "bio_fresh_plus_bottom_zone": {
-        "default": "mdi:leaf"
-      },
-      "bio_fresh_plus_middle_zone": {
-        "default": "mdi:leaf"
-      },
-      "bio_fresh_plus_top_zone": {
-        "default": "mdi:leaf"
-      },
-      "hydro_breeze": {
-        "default": "mdi:weather-windy"
-      },
-      "hydro_breeze_bottom_zone": {
-        "default": "mdi:weather-windy"
-      },
-      "hydro_breeze_middle_zone": {
-        "default": "mdi:weather-windy"
-      },
-      "hydro_breeze_top_zone": {
-        "default": "mdi:weather-windy"
-      },
-      "ice_maker": {
-        "default": "mdi:cube-outline",
-        "state": {
-          "off": "mdi:cube-outline-off"
-        }
-      },
-      "ice_maker_bottom_zone": {
-        "default": "mdi:cube-outline",
-        "state": {
-          "off": "mdi:cube-outline-off"
-        }
-      },
-      "ice_maker_middle_zone": {
-        "default": "mdi:cube-outline",
-        "state": {
-          "off": "mdi:cube-outline-off"
-        }
-      },
-      "ice_maker_top_zone": {
-        "default": "mdi:cube-outline",
-        "state": {
-          "off": "mdi:cube-outline-off"
-        }
-      }
-    },
     "switch": {
       "night_mode": {
         "default": "mdi:sleep",

homeassistant/components/liebherr/select.py

@@ -1,216 +0,0 @@
-"""Select platform for Liebherr integration."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Coroutine
-from dataclasses import dataclass
-from enum import StrEnum
-from typing import TYPE_CHECKING, Any
-
-from pyliebherrhomeapi import (
-    BioFreshPlusControl,
-    BioFreshPlusMode,
-    HydroBreezeControl,
-    HydroBreezeMode,
-    IceMakerControl,
-    IceMakerMode,
-    ZonePosition,
-)
-
-from homeassistant.components.select import SelectEntity, SelectEntityDescription
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
-from .entity import ZONE_POSITION_MAP, LiebherrEntity
-
-PARALLEL_UPDATES = 1
-
-type SelectControl = IceMakerControl | HydroBreezeControl | BioFreshPlusControl
-
-
-@dataclass(frozen=True, kw_only=True)
-class LiebherrSelectEntityDescription(SelectEntityDescription):
-    """Describes a Liebherr select entity."""
-
-    control_type: type[SelectControl]
-    mode_enum: type[StrEnum]
-    current_mode_fn: Callable[[SelectControl], StrEnum | str | None]
-    options_fn: Callable[[SelectControl], list[str]]
-    set_fn: Callable[[LiebherrCoordinator, int, StrEnum], Coroutine[Any, Any, None]]
-
-
-def _ice_maker_options(control: SelectControl) -> list[str]:
-    """Return available ice maker options."""
-    if TYPE_CHECKING:
-        assert isinstance(control, IceMakerControl)
-    options = [IceMakerMode.OFF.value, IceMakerMode.ON.value]
-    if control.has_max_ice:
-        options.append(IceMakerMode.MAX_ICE.value)
-    return options
-
-
-def _hydro_breeze_options(control: SelectControl) -> list[str]:
-    """Return available HydroBreeze options."""
-    return [mode.value for mode in HydroBreezeMode]
-
-
-def _bio_fresh_plus_options(control: SelectControl) -> list[str]:
-    """Return available BioFresh-Plus options."""
-    if TYPE_CHECKING:
-        assert isinstance(control, BioFreshPlusControl)
-    return [
-        mode.value
-        for mode in control.supported_modes
-        if isinstance(mode, BioFreshPlusMode)
-    ]
-
-
-SELECT_TYPES: list[LiebherrSelectEntityDescription] = [
-    LiebherrSelectEntityDescription(
-        key="ice_maker",
-        translation_key="ice_maker",
-        control_type=IceMakerControl,
-        mode_enum=IceMakerMode,
-        current_mode_fn=lambda c: c.ice_maker_mode,  # type: ignore[union-attr]
-        options_fn=_ice_maker_options,
-        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_ice_maker(
-            device_id=coordinator.device_id,
-            zone_id=zone_id,
-            mode=mode,  # type: ignore[arg-type]
-        ),
-    ),
-    LiebherrSelectEntityDescription(
-        key="hydro_breeze",
-        translation_key="hydro_breeze",
-        control_type=HydroBreezeControl,
-        mode_enum=HydroBreezeMode,
-        current_mode_fn=lambda c: c.current_mode,  # type: ignore[union-attr]
-        options_fn=_hydro_breeze_options,
-        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_hydro_breeze(
-            device_id=coordinator.device_id,
-            zone_id=zone_id,
-            mode=mode,  # type: ignore[arg-type]
-        ),
-    ),
-    LiebherrSelectEntityDescription(
-        key="bio_fresh_plus",
-        translation_key="bio_fresh_plus",
-        control_type=BioFreshPlusControl,
-        mode_enum=BioFreshPlusMode,
-        current_mode_fn=lambda c: c.current_mode,  # type: ignore[union-attr]
-        options_fn=_bio_fresh_plus_options,
-        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_bio_fresh_plus(
-            device_id=coordinator.device_id,
-            zone_id=zone_id,
-            mode=mode,  # type: ignore[arg-type]
-        ),
-    ),
-]
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: LiebherrConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Liebherr select entities."""
-    entities: list[LiebherrSelectEntity] = []
-
-    for coordinator in entry.runtime_data.values():
-        has_multiple_zones = len(coordinator.data.get_temperature_controls()) > 1
-
-        for control in coordinator.data.controls:
-            for description in SELECT_TYPES:
-                if isinstance(control, description.control_type):
-                    if TYPE_CHECKING:
-                        assert isinstance(
-                            control,
-                            IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
-                        )
-                    entities.append(
-                        LiebherrSelectEntity(
-                            coordinator=coordinator,
-                            description=description,
-                            zone_id=control.zone_id,
-                            has_multiple_zones=has_multiple_zones,
-                        )
-                    )
-
-    async_add_entities(entities)
-
-
-class LiebherrSelectEntity(LiebherrEntity, SelectEntity):
-    """Representation of a Liebherr select entity."""
-
-    entity_description: LiebherrSelectEntityDescription
-
-    def __init__(
-        self,
-        coordinator: LiebherrCoordinator,
-        description: LiebherrSelectEntityDescription,
-        zone_id: int,
-        has_multiple_zones: bool,
-    ) -> None:
-        """Initialize the select entity."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._zone_id = zone_id
-        self._attr_unique_id = f"{coordinator.device_id}_{description.key}_{zone_id}"
-
-        # Set options from the control
-        control = self._select_control
-        if control is not None:
-            self._attr_options = description.options_fn(control)
-
-        # Add zone suffix only for multi-zone devices
-        if has_multiple_zones:
-            temp_controls = coordinator.data.get_temperature_controls()
-            if (
-                (tc := temp_controls.get(zone_id))
-                and isinstance(tc.zone_position, ZonePosition)
-                and (zone_key := ZONE_POSITION_MAP.get(tc.zone_position))
-            ):
-                self._attr_translation_key = f"{description.translation_key}_{zone_key}"
-
-    @property
-    def _select_control(self) -> SelectControl | None:
-        """Get the select control for this entity."""
-        for control in self.coordinator.data.controls:
-            if (
-                isinstance(control, self.entity_description.control_type)
-                and control.zone_id == self._zone_id
-            ):
-                if TYPE_CHECKING:
-                    assert isinstance(
-                        control,
-                        IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
-                    )
-                return control
-        return None
-
-    @property
-    def current_option(self) -> str | None:
-        """Return the current selected option."""
-        control = self._select_control
-        if TYPE_CHECKING:
-            assert isinstance(
-                control,
-                IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
-            )
-        mode = self.entity_description.current_mode_fn(control)
-        if isinstance(mode, StrEnum):
-            return mode.value
-        return None
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return super().available and self._select_control is not None
-
-    async def async_select_option(self, option: str) -> None:
-        """Change the selected option."""
-        mode = self.entity_description.mode_enum(option)
-        await self._async_send_command(
-            self.entity_description.set_fn(self.coordinator, self._zone_id, mode),
-        )

homeassistant/components/liebherr/strings.json

@@ -47,112 +47,6 @@
         "name": "Top zone setpoint"
       }
     },
-    "select": {
-      "bio_fresh_plus": {
-        "name": "BioFresh-Plus",
-        "state": {
-          "minus_two_minus_two": "-2°C | -2°C",
-          "minus_two_zero": "-2°C | 0°C",
-          "zero_minus_two": "0°C | -2°C",
-          "zero_zero": "0°C | 0°C"
-        }
-      },
-      "bio_fresh_plus_bottom_zone": {
-        "name": "Bottom zone BioFresh-Plus",
-        "state": {
-          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
-          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
-          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
-          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
-        }
-      },
-      "bio_fresh_plus_middle_zone": {
-        "name": "Middle zone BioFresh-Plus",
-        "state": {
-          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
-          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
-          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
-          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
-        }
-      },
-      "bio_fresh_plus_top_zone": {
-        "name": "Top zone BioFresh-Plus",
-        "state": {
-          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
-          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
-          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
-          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
-        }
-      },
-      "hydro_breeze": {
-        "name": "HydroBreeze",
-        "state": {
-          "high": "[%key:common::state::high%]",
-          "low": "[%key:common::state::low%]",
-          "medium": "[%key:common::state::medium%]",
-          "off": "[%key:common::state::off%]"
-        }
-      },
-      "hydro_breeze_bottom_zone": {
-        "name": "Bottom zone HydroBreeze",
-        "state": {
-          "high": "[%key:common::state::high%]",
-          "low": "[%key:common::state::low%]",
-          "medium": "[%key:common::state::medium%]",
-          "off": "[%key:common::state::off%]"
-        }
-      },
-      "hydro_breeze_middle_zone": {
-        "name": "Middle zone HydroBreeze",
-        "state": {
-          "high": "[%key:common::state::high%]",
-          "low": "[%key:common::state::low%]",
-          "medium": "[%key:common::state::medium%]",
-          "off": "[%key:common::state::off%]"
-        }
-      },
-      "hydro_breeze_top_zone": {
-        "name": "Top zone HydroBreeze",
-        "state": {
-          "high": "[%key:common::state::high%]",
-          "low": "[%key:common::state::low%]",
-          "medium": "[%key:common::state::medium%]",
-          "off": "[%key:common::state::off%]"
-        }
-      },
-      "ice_maker": {
-        "name": "IceMaker",
-        "state": {
-          "max_ice": "MaxIce",
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]"
-        }
-      },
-      "ice_maker_bottom_zone": {
-        "name": "Bottom zone IceMaker",
-        "state": {
-          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]"
-        }
-      },
-      "ice_maker_middle_zone": {
-        "name": "Middle zone IceMaker",
-        "state": {
-          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]"
-        }
-      },
-      "ice_maker_top_zone": {
-        "name": "Top zone IceMaker",
-        "state": {
-          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]"
-        }
-      }
-    },
     "sensor": {
       "bottom_zone": {
         "name": "Bottom zone"

homeassistant/components/litterrobot/coordinator.py

@@ -65,7 +65,7 @@ class LitterRobotDataUpdateCoordinator(DataUpdateCoordinator[None]):
         except LitterRobotLoginException as ex:
             raise ConfigEntryAuthFailed("Invalid credentials") from ex
         except LitterRobotException as ex:
-            raise UpdateFailed("Unable to connect to Whisker API") from ex
+            raise UpdateFailed("Unable to connect to Litter-Robot API") from ex
 
     def litter_robots(self) -> Generator[LitterRobot]:
         """Get Litter-Robots from the account."""

homeassistant/components/litterrobot/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "litterrobot",
-  "name": "Whisker",
+  "name": "Litter-Robot",
   "codeowners": ["@natekspencer", "@tkdrob"],
   "config_flow": true,
   "dhcp": [

homeassistant/components/lunatone/light.py

@@ -109,18 +109,14 @@ class LunatoneLight(
         return self._device is not None and self._device.is_on
 
     @property
-    def brightness(self) -> int | None:
+    def brightness(self) -> int:
         """Return the brightness of this light between 0..255."""
-        return (
-            value_to_brightness(self.BRIGHTNESS_SCALE, self._device.brightness)
-            if self._device.brightness is not None
-            else None
-        )
+        return value_to_brightness(self.BRIGHTNESS_SCALE, self._device.brightness)
 
     @property
     def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
-        if self._device is not None and self._device.brightness is not None:
+        if self._device is not None and self._device.is_dimmable:
             return ColorMode.BRIGHTNESS
         return ColorMode.ONOFF
 
@@ -153,8 +149,7 @@ class LunatoneLight(
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""
         if brightness_supported(self.supported_color_modes):
-            if self.brightness:
-                self._last_brightness = self.brightness
+            self._last_brightness = self.brightness
             await self._device.fade_to_brightness(0)
         else:
             await self._device.switch_off()

homeassistant/components/lunatone/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["lunatone-rest-api-client==0.7.0"]
+  "requirements": ["lunatone-rest-api-client==0.6.3"]
 }

homeassistant/components/matter/manifest.json

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

homeassistant/components/media_extractor/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "calculated",
   "loggers": ["yt_dlp"],
   "quality_scale": "internal",
-  "requirements": ["yt-dlp[default]==2026.02.21"],
+  "requirements": ["yt-dlp[default]==2026.02.04"],
   "single_config_entry": true
 }

homeassistant/components/mta/__init__.py

@@ -2,12 +2,10 @@
 
 from __future__ import annotations
 
-import asyncio
-
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN as DOMAIN, SUBENTRY_TYPE_BUS, SUBENTRY_TYPE_SUBWAY
+from .const import DOMAIN as DOMAIN
 from .coordinator import MTAConfigEntry, MTADataUpdateCoordinator
 
 PLATFORMS = [Platform.SENSOR]
@@ -15,36 +13,16 @@ PLATFORMS = [Platform.SENSOR]
 
 async def async_setup_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> bool:
     """Set up MTA from a config entry."""
-    coordinators: dict[str, MTADataUpdateCoordinator] = {}
+    coordinator = MTADataUpdateCoordinator(hass, entry)
+    await coordinator.async_config_entry_first_refresh()
 
-    for subentry_id, subentry in entry.subentries.items():
-        if subentry.subentry_type not in (SUBENTRY_TYPE_SUBWAY, SUBENTRY_TYPE_BUS):
-            continue
-
-        coordinators[subentry_id] = MTADataUpdateCoordinator(hass, entry, subentry)
-
-    # Refresh all coordinators in parallel
-    await asyncio.gather(
-        *(
-            coordinator.async_config_entry_first_refresh()
-            for coordinator in coordinators.values()
-        )
-    )
-
-    entry.runtime_data = coordinators
-
-    entry.async_on_unload(entry.add_update_listener(async_update_entry))
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_update_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> None:
-    """Handle config entry update (e.g., subentry changes)."""
-    await hass.config_entries.async_reload(entry.entry_id)
-
-
 async def async_unload_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/mta/config_flow.py

@@ -2,43 +2,22 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
 import logging
 from typing import Any
 
-from pymta import LINE_TO_FEED, BusFeed, MTAFeedError, SubwayFeed
+from pymta import LINE_TO_FEED, MTAFeedError, SubwayFeed
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    SOURCE_REAUTH,
-    ConfigEntry,
-    ConfigFlow,
-    ConfigFlowResult,
-    ConfigSubentryFlow,
-    SubentryFlowResult,
-)
-from homeassistant.const import CONF_API_KEY
-from homeassistant.core import callback
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.helpers import aiohttp_client
 from homeassistant.helpers.selector import (
     SelectOptionDict,
     SelectSelector,
     SelectSelectorConfig,
     SelectSelectorMode,
-    TextSelector,
-    TextSelectorConfig,
-    TextSelectorType,
 )
 
-from .const import (
-    CONF_LINE,
-    CONF_ROUTE,
-    CONF_STOP_ID,
-    CONF_STOP_NAME,
-    DOMAIN,
-    SUBENTRY_TYPE_BUS,
-    SUBENTRY_TYPE_SUBWAY,
-)
+from .const import CONF_LINE, CONF_STOP_ID, CONF_STOP_NAME, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -49,79 +28,17 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
     VERSION = 1
     MINOR_VERSION = 1
 
-    @classmethod
-    @callback
-    def async_get_supported_subentry_types(
-        cls, config_entry: ConfigEntry
-    ) -> dict[str, type[ConfigSubentryFlow]]:
-        """Return subentries supported by this handler."""
-        return {
-            SUBENTRY_TYPE_SUBWAY: SubwaySubentryFlowHandler,
-            SUBENTRY_TYPE_BUS: BusSubentryFlowHandler,
-        }
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self.data: dict[str, Any] = {}
+        self.stops: dict[str, str] = {}
 
     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:
-            api_key = user_input.get(CONF_API_KEY)
-            self._async_abort_entries_match({CONF_API_KEY: api_key})
-            if api_key:
-                # Test the API key by trying to fetch bus data
-                session = async_get_clientsession(self.hass)
-                bus_feed = BusFeed(api_key=api_key, session=session)
-                try:
-                    # Try to get stops for a known route to validate the key
-                    await bus_feed.get_stops(route_id="M15")
-                except MTAFeedError:
-                    errors["base"] = "cannot_connect"
-                except Exception:
-                    _LOGGER.exception("Unexpected error validating API key")
-                    errors["base"] = "unknown"
-            if not errors:
-                if self.source == SOURCE_REAUTH:
-                    return self.async_update_reload_and_abort(
-                        self._get_reauth_entry(),
-                        data_updates={CONF_API_KEY: api_key or None},
-                    )
-                return self.async_create_entry(
-                    title="MTA",
-                    data={CONF_API_KEY: api_key or None},
-                )
 
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Optional(CONF_API_KEY): TextSelector(
-                        TextSelectorConfig(type=TextSelectorType.PASSWORD)
-                    ),
-                }
-            ),
-            errors=errors,
-        )
-
-    async def async_step_reauth(
-        self, _entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reauth when user wants to add or update API key."""
-        return await self.async_step_user()
-
-
-class SubwaySubentryFlowHandler(ConfigSubentryFlow):
-    """Handle subway stop subentry flow."""
-
-    def __init__(self) -> None:
-        """Initialize the subentry flow."""
-        self.data: dict[str, Any] = {}
-        self.stops: dict[str, str] = {}
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle the line selection step."""
         if user_input is not None:
             self.data[CONF_LINE] = user_input[CONF_LINE]
             return await self.async_step_stop()
@@ -141,12 +58,13 @@ class SubwaySubentryFlowHandler(ConfigSubentryFlow):
                     ),
                 }
             ),
+            errors=errors,
         )
 
     async def async_step_stop(
         self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle the stop selection step."""
+    ) -> ConfigFlowResult:
+        """Handle the stop step."""
         errors: dict[str, str] = {}
 
         if user_input is not None:
@@ -156,30 +74,25 @@ class SubwaySubentryFlowHandler(ConfigSubentryFlow):
             self.data[CONF_STOP_NAME] = stop_name
 
             unique_id = f"{self.data[CONF_LINE]}_{stop_id}"
+            await self.async_set_unique_id(unique_id)
+            self._abort_if_unique_id_configured()
 
-            # Check for duplicate subentries across all entries
-            for entry in self.hass.config_entries.async_entries(DOMAIN):
-                for subentry in entry.subentries.values():
-                    if subentry.unique_id == unique_id:
-                        return self.async_abort(reason="already_configured")
-
-            # Test connection to real-time GTFS-RT feed
+            # Test connection to real-time GTFS-RT feed (different from static GTFS used by get_stops)
             try:
                 await self._async_test_connection()
             except MTAFeedError:
                 errors["base"] = "cannot_connect"
             else:
-                title = f"{self.data[CONF_LINE]} - {stop_name}"
+                title = f"{self.data[CONF_LINE]} Line - {stop_name}"
                 return self.async_create_entry(
                     title=title,
                     data=self.data,
-                    unique_id=unique_id,
                 )
 
         try:
             self.stops = await self._async_get_stops(self.data[CONF_LINE])
         except MTAFeedError:
-            _LOGGER.debug("Error fetching stops for line %s", self.data[CONF_LINE])
+            _LOGGER.exception("Error fetching stops for line %s", self.data[CONF_LINE])
             return self.async_abort(reason="cannot_connect")
 
         if not self.stops:
@@ -210,7 +123,7 @@ class SubwaySubentryFlowHandler(ConfigSubentryFlow):
     async def _async_get_stops(self, line: str) -> dict[str, str]:
         """Get stops for a line from the library."""
         feed_id = SubwayFeed.get_feed_id_for_route(line)
-        session = async_get_clientsession(self.hass)
+        session = aiohttp_client.async_get_clientsession(self.hass)
 
         subway_feed = SubwayFeed(feed_id=feed_id, session=session)
         stops_list = await subway_feed.get_stops(route_id=line)
@@ -228,7 +141,7 @@ class SubwaySubentryFlowHandler(ConfigSubentryFlow):
     async def _async_test_connection(self) -> None:
         """Test connection to MTA feed."""
         feed_id = SubwayFeed.get_feed_id_for_route(self.data[CONF_LINE])
-        session = async_get_clientsession(self.hass)
+        session = aiohttp_client.async_get_clientsession(self.hass)
 
         subway_feed = SubwayFeed(feed_id=feed_id, session=session)
         await subway_feed.get_arrivals(
@@ -236,133 +149,3 @@ class SubwaySubentryFlowHandler(ConfigSubentryFlow):
             stop_id=self.data[CONF_STOP_ID],
             max_arrivals=1,
         )
-
-
-class BusSubentryFlowHandler(ConfigSubentryFlow):
-    """Handle bus stop subentry flow."""
-
-    def __init__(self) -> None:
-        """Initialize the subentry flow."""
-        self.data: dict[str, Any] = {}
-        self.stops: dict[str, str] = {}
-
-    def _get_api_key(self) -> str:
-        """Get API key from parent entry."""
-        return self._get_entry().data.get(CONF_API_KEY) or ""
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle the route input step."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            route = user_input[CONF_ROUTE].upper().strip()
-            self.data[CONF_ROUTE] = route
-
-            # Validate route by fetching stops
-            try:
-                self.stops = await self._async_get_stops(route)
-                if not self.stops:
-                    errors["base"] = "invalid_route"
-                else:
-                    return await self.async_step_stop()
-            except MTAFeedError:
-                _LOGGER.debug("Error fetching stops for route %s", route)
-                errors["base"] = "invalid_route"
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_ROUTE): TextSelector(),
-                }
-            ),
-            errors=errors,
-        )
-
-    async def async_step_stop(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle the stop selection step."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            stop_id = user_input[CONF_STOP_ID]
-            self.data[CONF_STOP_ID] = stop_id
-            stop_name = self.stops.get(stop_id, stop_id)
-            self.data[CONF_STOP_NAME] = stop_name
-
-            unique_id = f"bus_{self.data[CONF_ROUTE]}_{stop_id}"
-
-            # Check for duplicate subentries across all entries
-            for entry in self.hass.config_entries.async_entries(DOMAIN):
-                for subentry in entry.subentries.values():
-                    if subentry.unique_id == unique_id:
-                        return self.async_abort(reason="already_configured")
-
-            # Test connection to real-time feed
-            try:
-                await self._async_test_connection()
-            except MTAFeedError:
-                errors["base"] = "cannot_connect"
-            else:
-                title = f"{self.data[CONF_ROUTE]} - {stop_name}"
-                return self.async_create_entry(
-                    title=title,
-                    data=self.data,
-                    unique_id=unique_id,
-                )
-
-        stop_options = [
-            SelectOptionDict(value=stop_id, label=stop_name)
-            for stop_id, stop_name in sorted(self.stops.items(), key=lambda x: x[1])
-        ]
-
-        return self.async_show_form(
-            step_id="stop",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_STOP_ID): SelectSelector(
-                        SelectSelectorConfig(
-                            options=stop_options,
-                            mode=SelectSelectorMode.DROPDOWN,
-                        )
-                    ),
-                }
-            ),
-            errors=errors,
-            description_placeholders={"route": self.data[CONF_ROUTE]},
-        )
-
-    async def _async_get_stops(self, route: str) -> dict[str, str]:
-        """Get stops for a bus route from the library."""
-        session = async_get_clientsession(self.hass)
-        api_key = self._get_api_key()
-
-        bus_feed = BusFeed(api_key=api_key, session=session)
-        stops_list = await bus_feed.get_stops(route_id=route)
-
-        stops = {}
-        for stop in stops_list:
-            stop_id = stop["stop_id"]
-            stop_name = stop["stop_name"]
-            # Add direction if available (e.g., "to South Ferry")
-            if direction := stop.get("direction_name"):
-                stops[stop_id] = f"{stop_name} (to {direction})"
-            else:
-                stops[stop_id] = stop_name
-
-        return stops
-
-    async def _async_test_connection(self) -> None:
-        """Test connection to MTA bus feed."""
-        session = async_get_clientsession(self.hass)
-        api_key = self._get_api_key()
-
-        bus_feed = BusFeed(api_key=api_key, session=session)
-        await bus_feed.get_arrivals(
-            route_id=self.data[CONF_ROUTE],
-            stop_id=self.data[CONF_STOP_ID],
-            max_arrivals=1,
-        )

homeassistant/components/mta/const.py

@@ -7,9 +7,5 @@ DOMAIN = "mta"
 CONF_LINE = "line"
 CONF_STOP_ID = "stop_id"
 CONF_STOP_NAME = "stop_name"
-CONF_ROUTE = "route"
-
-SUBENTRY_TYPE_SUBWAY = "subway"
-SUBENTRY_TYPE_BUS = "bus"
 
 UPDATE_INTERVAL = timedelta(seconds=30)

homeassistant/components/mta/coordinator.py

@@ -6,30 +6,22 @@ from dataclasses import dataclass
 from datetime import datetime
 import logging
 
-from pymta import BusFeed, MTAFeedError, SubwayFeed
+from pymta import MTAFeedError, SubwayFeed
 
-from homeassistant.config_entries import ConfigEntry, ConfigSubentry
-from homeassistant.const import CONF_API_KEY
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
-from .const import (
-    CONF_LINE,
-    CONF_ROUTE,
-    CONF_STOP_ID,
-    DOMAIN,
-    SUBENTRY_TYPE_BUS,
-    UPDATE_INTERVAL,
-)
+from .const import CONF_LINE, CONF_STOP_ID, DOMAIN, UPDATE_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
 
 @dataclass
 class MTAArrival:
-    """Represents a single transit arrival."""
+    """Represents a single train arrival."""
 
     arrival_time: datetime
     minutes_until: int
@@ -44,7 +36,7 @@ class MTAData:
     arrivals: list[MTAArrival]
 
 
-type MTAConfigEntry = ConfigEntry[dict[str, MTADataUpdateCoordinator]]
+type MTAConfigEntry = ConfigEntry[MTADataUpdateCoordinator]
 
 
 class MTADataUpdateCoordinator(DataUpdateCoordinator[MTAData]):
@@ -52,48 +44,35 @@ class MTADataUpdateCoordinator(DataUpdateCoordinator[MTAData]):
 
     config_entry: MTAConfigEntry
 
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: MTAConfigEntry,
-        subentry: ConfigSubentry,
-    ) -> None:
+    def __init__(self, hass: HomeAssistant, config_entry: MTAConfigEntry) -> None:
         """Initialize."""
-        self.subentry = subentry
-        self.stop_id = subentry.data[CONF_STOP_ID]
+        self.line = config_entry.data[CONF_LINE]
+        self.stop_id = config_entry.data[CONF_STOP_ID]
 
+        self.feed_id = SubwayFeed.get_feed_id_for_route(self.line)
         session = async_get_clientsession(hass)
-
-        if subentry.subentry_type == SUBENTRY_TYPE_BUS:
-            api_key = config_entry.data.get(CONF_API_KEY) or ""
-            self.feed: BusFeed | SubwayFeed = BusFeed(api_key=api_key, session=session)
-            self.route_id = subentry.data[CONF_ROUTE]
-        else:
-            # Subway feed
-            line = subentry.data[CONF_LINE]
-            feed_id = SubwayFeed.get_feed_id_for_route(line)
-            self.feed = SubwayFeed(feed_id=feed_id, session=session)
-            self.route_id = line
+        self.subway_feed = SubwayFeed(feed_id=self.feed_id, session=session)
 
         super().__init__(
             hass,
             _LOGGER,
             config_entry=config_entry,
-            name=f"{DOMAIN}_{subentry.subentry_id}",
+            name=DOMAIN,
             update_interval=UPDATE_INTERVAL,
         )
 
     async def _async_update_data(self) -> MTAData:
         """Fetch data from MTA."""
         _LOGGER.debug(
-            "Fetching data for route=%s, stop=%s",
-            self.route_id,
+            "Fetching data for line=%s, stop=%s, feed=%s",
+            self.line,
             self.stop_id,
+            self.feed_id,
         )
 
         try:
-            library_arrivals = await self.feed.get_arrivals(
-                route_id=self.route_id,
+            library_arrivals = await self.subway_feed.get_arrivals(
+                route_id=self.line,
                 stop_id=self.stop_id,
                 max_arrivals=3,
             )

homeassistant/components/mta/quality_scale.yaml

@@ -38,7 +38,9 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: done
+  reauthentication-flow:
+    status: exempt
+    comment: No authentication required.
   test-coverage: done
 
   # Gold

homeassistant/components/mta/sensor.py

@@ -11,13 +11,12 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.config_entries import ConfigSubentry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import CONF_LINE, CONF_ROUTE, CONF_STOP_NAME, DOMAIN, SUBENTRY_TYPE_BUS
+from .const import CONF_LINE, CONF_STOP_ID, CONF_STOP_NAME, DOMAIN
 from .coordinator import MTAArrival, MTAConfigEntry, MTADataUpdateCoordinator
 
 PARALLEL_UPDATES = 0
@@ -98,19 +97,16 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up MTA sensor based on a config entry."""
-    for subentry_id, coordinator in entry.runtime_data.items():
-        subentry = entry.subentries[subentry_id]
-        async_add_entities(
-            (
-                MTASensor(coordinator, subentry, description)
-                for description in SENSOR_DESCRIPTIONS
-            ),
-            config_subentry_id=subentry_id,
-        )
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        MTASensor(coordinator, entry, description)
+        for description in SENSOR_DESCRIPTIONS
+    )
 
 
 class MTASensor(CoordinatorEntity[MTADataUpdateCoordinator], SensorEntity):
-    """Sensor for MTA transit arrivals."""
+    """Sensor for MTA train arrivals."""
 
     _attr_has_entity_name = True
     entity_description: MTASensorEntityDescription
@@ -118,32 +114,24 @@ class MTASensor(CoordinatorEntity[MTADataUpdateCoordinator], SensorEntity):
     def __init__(
         self,
         coordinator: MTADataUpdateCoordinator,
-        subentry: ConfigSubentry,
+        entry: MTAConfigEntry,
         description: MTASensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator)
 
         self.entity_description = description
+        line = entry.data[CONF_LINE]
+        stop_id = entry.data[CONF_STOP_ID]
+        stop_name = entry.data.get(CONF_STOP_NAME, stop_id)
 
-        is_bus = subentry.subentry_type == SUBENTRY_TYPE_BUS
-        if is_bus:
-            route = subentry.data[CONF_ROUTE]
-            model = "Bus"
-        else:
-            route = subentry.data[CONF_LINE]
-            model = "Subway"
-
-        stop_name = subentry.data.get(CONF_STOP_NAME, subentry.subentry_id)
-
-        unique_id = subentry.unique_id or subentry.subentry_id
-        self._attr_unique_id = f"{unique_id}-{description.key}"
+        self._attr_unique_id = f"{entry.unique_id}-{description.key}"
 
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, unique_id)},
-            name=f"{route} - {stop_name}",
+            identifiers={(DOMAIN, entry.entry_id)},
+            name=f"{line} Line - {stop_name} ({stop_id})",
             manufacturer="MTA",
-            model=model,
+            model="Subway",
             entry_type=DeviceEntryType.SERVICE,
         )
 

homeassistant/components/mta/strings.json

@@ -2,95 +2,32 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "no_stops": "No stops found for this line. The line may not be currently running."
     },
     "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
     },
     "step": {
-      "user": {
+      "stop": {
         "data": {
-          "api_key": "[%key:common::config_flow::data::api_key%]"
+          "stop_id": "Stop and direction"
         },
         "data_description": {
-          "api_key": "API key from MTA Bus Time. Required for bus tracking, optional for subway only."
+          "stop_id": "Select the stop and direction you want to track"
         },
-        "description": "Enter your MTA Bus Time API key to enable bus tracking. Leave blank if you only want to track subways."
-      }
-    }
-  },
-  "config_subentries": {
-    "bus": {
-      "abort": {
-        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+        "description": "Choose a stop on the {line} line. The direction is included with each stop.",
+        "title": "Select stop and direction"
       },
-      "entry_type": "Bus stop",
-      "error": {
-        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-        "invalid_route": "Invalid bus route. Please check the route name and try again."
-      },
-      "initiate_flow": {
-        "user": "Add bus stop"
-      },
-      "step": {
-        "stop": {
-          "data": {
-            "stop_id": "Stop"
-          },
-          "data_description": {
-            "stop_id": "Select the stop you want to track"
-          },
-          "description": "Choose a stop on the {route} route.",
-          "title": "Select stop"
+      "user": {
+        "data": {
+          "line": "Line"
         },
-        "user": {
-          "data": {
-            "route": "Route"
-          },
-          "data_description": {
-            "route": "The bus route identifier"
-          },
-          "description": "Enter the bus route you want to track (for example, M15, B46, Q10).",
-          "title": "Enter bus route"
-        }
-      }
-    },
-    "subway": {
-      "abort": {
-        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-        "no_stops": "No stops found for this line. The line may not be currently running."
-      },
-      "entry_type": "Subway stop",
-      "error": {
-        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
-      },
-      "initiate_flow": {
-        "user": "Add subway stop"
-      },
-      "step": {
-        "stop": {
-          "data": {
-            "stop_id": "Stop and direction"
-          },
-          "data_description": {
-            "stop_id": "Select the stop and direction you want to track"
-          },
-          "description": "Choose a stop on the {line} line. The direction is included with each stop.",
-          "title": "Select stop and direction"
+        "data_description": {
+          "line": "The subway line to track"
         },
-        "user": {
-          "data": {
-            "line": "Line"
-          },
-          "data_description": {
-            "line": "The subway line to track"
-          },
-          "description": "Choose the subway line you want to track.",
-          "title": "Select subway line"
-        }
+        "description": "Choose the subway line you want to track.",
+        "title": "Select subway line"
       }
     }
   },

homeassistant/components/myneomitis/__init__.py

@@ -1,130 +0,0 @@
-"""Integration for MyNeomitis."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-from typing import Any
-
-import aiohttp
-import pyaxencoapi
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    CONF_EMAIL,
-    CONF_PASSWORD,
-    EVENT_HOMEASSISTANT_STOP,
-    Platform,
-)
-from homeassistant.core import Event, HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-_LOGGER = logging.getLogger(__name__)
-
-PLATFORMS = [Platform.SELECT]
-
-
-@dataclass
-class MyNeomitisRuntimeData:
-    """Runtime data for MyNeomitis integration."""
-
-    api: pyaxencoapi.PyAxencoAPI
-    devices: list[dict[str, Any]]
-
-
-type MyNeomitisConfigEntry = ConfigEntry[MyNeomitisRuntimeData]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: MyNeomitisConfigEntry) -> bool:
-    """Set up MyNeomitis from a config entry."""
-    session = async_get_clientsession(hass)
-
-    email: str = entry.data[CONF_EMAIL]
-    password: str = entry.data[CONF_PASSWORD]
-
-    api = pyaxencoapi.PyAxencoAPI(session)
-    connected = False
-    try:
-        await api.login(email, password)
-        await api.connect_websocket()
-        connected = True
-        _LOGGER.debug("Successfully connected to Login/WebSocket")
-
-        # Retrieve the user's devices
-        devices: list[dict[str, Any]] = await api.get_devices()
-
-    except aiohttp.ClientResponseError as err:
-        if connected:
-            try:
-                await api.disconnect_websocket()
-            except (
-                TimeoutError,
-                ConnectionError,
-                aiohttp.ClientError,
-            ) as disconnect_err:
-                _LOGGER.error(
-                    "Error while disconnecting WebSocket for %s: %s",
-                    entry.entry_id,
-                    disconnect_err,
-                )
-        if err.status == 401:
-            raise ConfigEntryAuthFailed(
-                "Authentication failed, please update your credentials"
-            ) from err
-        raise ConfigEntryNotReady(f"Error connecting to API: {err}") from err
-    except (TimeoutError, ConnectionError, aiohttp.ClientError) as err:
-        if connected:
-            try:
-                await api.disconnect_websocket()
-            except (
-                TimeoutError,
-                ConnectionError,
-                aiohttp.ClientError,
-            ) as disconnect_err:
-                _LOGGER.error(
-                    "Error while disconnecting WebSocket for %s: %s",
-                    entry.entry_id,
-                    disconnect_err,
-                )
-        raise ConfigEntryNotReady(f"Error connecting to API/WebSocket: {err}") from err
-
-    entry.runtime_data = MyNeomitisRuntimeData(api=api, devices=devices)
-
-    async def _async_disconnect_websocket(_event: Event) -> None:
-        """Disconnect WebSocket on Home Assistant shutdown."""
-        try:
-            await api.disconnect_websocket()
-        except (TimeoutError, ConnectionError, aiohttp.ClientError) as err:
-            _LOGGER.error(
-                "Error while disconnecting WebSocket for %s: %s",
-                entry.entry_id,
-                err,
-            )
-
-    entry.async_on_unload(
-        hass.bus.async_listen_once(
-            EVENT_HOMEASSISTANT_STOP, _async_disconnect_websocket
-        )
-    )
-
-    # Load platforms
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: MyNeomitisConfigEntry) -> bool:
-    """Unload a config entry."""
-    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-    if unload_ok:
-        try:
-            await entry.runtime_data.api.disconnect_websocket()
-        except (TimeoutError, ConnectionError) as err:
-            _LOGGER.error(
-                "Error while disconnecting WebSocket for %s: %s",
-                entry.entry_id,
-                err,
-            )
-
-    return unload_ok

homeassistant/components/myneomitis/config_flow.py

@@ -1,78 +0,0 @@
-"""Config flow for MyNeomitis integration."""
-
-import logging
-from typing import Any
-
-import aiohttp
-from pyaxencoapi import PyAxencoAPI
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-
-from .const import CONF_USER_ID, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-
-class MyNeoConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle the configuration flow for the MyNeomitis integration."""
-
-    VERSION = 1
-    MINOR_VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step of the configuration flow."""
-        errors: dict[str, str] = {}
-
-        if user_input is not None:
-            email: str = user_input[CONF_EMAIL]
-            password: str = user_input[CONF_PASSWORD]
-
-            session = async_get_clientsession(self.hass)
-            api = PyAxencoAPI(session)
-
-            try:
-                await api.login(email, password)
-            except aiohttp.ClientResponseError as e:
-                if e.status == 401:
-                    errors["base"] = "invalid_auth"
-                elif e.status >= 500:
-                    errors["base"] = "cannot_connect"
-                else:
-                    errors["base"] = "unknown"
-            except aiohttp.ClientConnectionError:
-                errors["base"] = "cannot_connect"
-            except aiohttp.ClientError:
-                errors["base"] = "unknown"
-            except Exception:
-                _LOGGER.exception("Unexpected error during login")
-                errors["base"] = "unknown"
-
-            if not errors:
-                # Prevent duplicate configuration with the same user ID
-                await self.async_set_unique_id(api.user_id)
-                self._abort_if_unique_id_configured()
-
-                return self.async_create_entry(
-                    title=f"MyNeomitis ({email})",
-                    data={
-                        CONF_EMAIL: email,
-                        CONF_PASSWORD: password,
-                        CONF_USER_ID: api.user_id,
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(CONF_EMAIL): str,
-                    vol.Required(CONF_PASSWORD): str,
-                }
-            ),
-            errors=errors,
-        )

homeassistant/components/myneomitis/const.py

@@ -1,4 +0,0 @@
-"""Constants for the MyNeomitis integration."""
-
-DOMAIN = "myneomitis"
-CONF_USER_ID = "user_id"

homeassistant/components/myneomitis/icons.json

@@ -1,31 +0,0 @@
-{
-  "entity": {
-    "select": {
-      "pilote": {
-        "state": {
-          "antifrost": "mdi:snowflake",
-          "auto": "mdi:refresh-auto",
-          "boost": "mdi:rocket-launch",
-          "comfort": "mdi:fire",
-          "eco": "mdi:leaf",
-          "eco_1": "mdi:leaf",
-          "eco_2": "mdi:leaf",
-          "standby": "mdi:toggle-switch-off-outline"
-        }
-      },
-      "relais": {
-        "state": {
-          "auto": "mdi:refresh-auto",
-          "off": "mdi:toggle-switch-off-outline",
-          "on": "mdi:toggle-switch"
-        }
-      },
-      "ufh": {
-        "state": {
-          "cooling": "mdi:snowflake",
-          "heating": "mdi:fire"
-        }
-      }
-    }
-  }
-}

homeassistant/components/myneomitis/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "myneomitis",
-  "name": "MyNeomitis",
-  "codeowners": ["@l-pr"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/myneomitis",
-  "integration_type": "hub",
-  "iot_class": "cloud_push",
-  "quality_scale": "bronze",
-  "requirements": ["pyaxencoapi==1.0.6"]
-}

homeassistant/components/myneomitis/quality_scale.yaml

@@ -1,76 +0,0 @@
-rules:
-  # Bronze tier rules
-  action-setup:
-    status: exempt
-    comment: Integration does not register service actions.
-  appropriate-polling:
-    status: exempt
-    comment: Integration uses WebSocket push updates, not polling.
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: Integration does not provide service actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver tier rules
-  action-exceptions:
-    status: exempt
-    comment: Integration does not provide service actions.
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: Integration has no configuration parameters beyond initial setup.
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates:
-    status: exempt
-    comment: Integration uses WebSocket callbacks to push updates directly to entities, not coordinator-based polling.
-  reauthentication-flow: todo
-  test-coverage: done
-
-  # Gold tier rules
-  devices: todo
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: Integration is cloud-based and does not use local discovery.
-  discovery:
-    status: exempt
-    comment: Integration requires manual authentication via cloud service.
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: todo
-  entity-disabled-by-default: todo
-  entity-translations: done
-  exception-translations: todo
-  icon-translations: todo
-  reconfiguration-flow: todo
-  repair-issues: todo
-  stale-devices: todo
-
-  # Platinum tier rules
-  async-dependency: done
-  inject-websession: done
-  strict-typing: todo

homeassistant/components/myneomitis/select.py

@@ -1,208 +0,0 @@
-"""Select entities for MyNeomitis integration.
-
-This module defines and sets up the select entities for the MyNeomitis integration.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-from typing import Any
-
-from pyaxencoapi import PyAxencoAPI
-
-from homeassistant.components.select import SelectEntity, SelectEntityDescription
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import MyNeomitisConfigEntry
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-SUPPORTED_MODELS: frozenset[str] = frozenset({"EWS"})
-SUPPORTED_SUB_MODELS: frozenset[str] = frozenset({"UFH"})
-
-PRESET_MODE_MAP = {
-    "comfort": 1,
-    "eco": 2,
-    "antifrost": 3,
-    "standby": 4,
-    "boost": 6,
-    "setpoint": 8,
-    "comfort_plus": 20,
-    "eco_1": 40,
-    "eco_2": 41,
-    "auto": 60,
-}
-
-PRESET_MODE_MAP_RELAIS = {
-    "on": 1,
-    "off": 2,
-    "auto": 60,
-}
-
-PRESET_MODE_MAP_UFH = {
-    "heating": 0,
-    "cooling": 1,
-}
-
-REVERSE_PRESET_MODE_MAP = {v: k for k, v in PRESET_MODE_MAP.items()}
-
-REVERSE_PRESET_MODE_MAP_RELAIS = {v: k for k, v in PRESET_MODE_MAP_RELAIS.items()}
-
-REVERSE_PRESET_MODE_MAP_UFH = {v: k for k, v in PRESET_MODE_MAP_UFH.items()}
-
-
-@dataclass(frozen=True, kw_only=True)
-class MyNeoSelectEntityDescription(SelectEntityDescription):
-    """Describe MyNeomitis select entity."""
-
-    preset_mode_map: dict[str, int]
-    reverse_preset_mode_map: dict[int, str]
-    state_key: str
-
-
-SELECT_TYPES: dict[str, MyNeoSelectEntityDescription] = {
-    "relais": MyNeoSelectEntityDescription(
-        key="relais",
-        translation_key="relais",
-        options=list(PRESET_MODE_MAP_RELAIS),
-        preset_mode_map=PRESET_MODE_MAP_RELAIS,
-        reverse_preset_mode_map=REVERSE_PRESET_MODE_MAP_RELAIS,
-        state_key="targetMode",
-    ),
-    "pilote": MyNeoSelectEntityDescription(
-        key="pilote",
-        translation_key="pilote",
-        options=list(PRESET_MODE_MAP),
-        preset_mode_map=PRESET_MODE_MAP,
-        reverse_preset_mode_map=REVERSE_PRESET_MODE_MAP,
-        state_key="targetMode",
-    ),
-    "ufh": MyNeoSelectEntityDescription(
-        key="ufh",
-        translation_key="ufh",
-        options=list(PRESET_MODE_MAP_UFH),
-        preset_mode_map=PRESET_MODE_MAP_UFH,
-        reverse_preset_mode_map=REVERSE_PRESET_MODE_MAP_UFH,
-        state_key="changeOverUser",
-    ),
-}
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: MyNeomitisConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Select entities from a config entry."""
-    api = config_entry.runtime_data.api
-    devices = config_entry.runtime_data.devices
-
-    def _create_entity(device: dict) -> MyNeoSelect:
-        """Create a select entity for a device."""
-        if device["model"] == "EWS":
-            # According to the MyNeomitis API, EWS "relais" devices expose a "relayMode"
-            # field in their state, while "pilote" devices do not. We therefore use the
-            # presence of "relayMode" as an explicit heuristic to distinguish relais
-            # from pilote devices. If the upstream API changes this behavior, this
-            # detection logic must be revisited.
-            if "relayMode" in device.get("state", {}):
-                description = SELECT_TYPES["relais"]
-            else:
-                description = SELECT_TYPES["pilote"]
-        else:  # UFH
-            description = SELECT_TYPES["ufh"]
-
-        return MyNeoSelect(api, device, description)
-
-    select_entities = [
-        _create_entity(device)
-        for device in devices
-        if device["model"] in SUPPORTED_MODELS | SUPPORTED_SUB_MODELS
-    ]
-
-    async_add_entities(select_entities)
-
-
-class MyNeoSelect(SelectEntity):
-    """Select entity for MyNeomitis devices."""
-
-    entity_description: MyNeoSelectEntityDescription
-    _attr_has_entity_name = True
-    _attr_name = None  # Entity represents the device itself
-    _attr_should_poll = False
-
-    def __init__(
-        self,
-        api: PyAxencoAPI,
-        device: dict[str, Any],
-        description: MyNeoSelectEntityDescription,
-    ) -> None:
-        """Initialize the MyNeoSelect entity."""
-        self.entity_description = description
-        self._api = api
-        self._device = device
-        self._attr_unique_id = device["_id"]
-        self._attr_available = device["connected"]
-        self._attr_device_info = dr.DeviceInfo(
-            identifiers={(DOMAIN, device["_id"])},
-            name=device["name"],
-            manufacturer="Axenco",
-            model=device["model"],
-        )
-        # Set current option based on device state
-        current_mode = device.get("state", {}).get(description.state_key)
-        self._attr_current_option = description.reverse_preset_mode_map.get(
-            current_mode
-        )
-        self._unavailable_logged: bool = False
-
-    async def async_added_to_hass(self) -> None:
-        """Register listener when entity is added to hass."""
-        await super().async_added_to_hass()
-        if unsubscribe := self._api.register_listener(
-            self._device["_id"], self.handle_ws_update
-        ):
-            self.async_on_remove(unsubscribe)
-
-    @callback
-    def handle_ws_update(self, new_state: dict[str, Any]) -> None:
-        """Handle WebSocket updates for the device."""
-        if not new_state:
-            return
-
-        if "connected" in new_state:
-            self._attr_available = new_state["connected"]
-            if not self._attr_available:
-                if not self._unavailable_logged:
-                    _LOGGER.info("The entity %s is unavailable", self.entity_id)
-                    self._unavailable_logged = True
-            elif self._unavailable_logged:
-                _LOGGER.info("The entity %s is back online", self.entity_id)
-                self._unavailable_logged = False
-
-        # Check for state updates using the description's state_key
-        state_key = self.entity_description.state_key
-        if state_key in new_state:
-            mode = new_state.get(state_key)
-            if mode is not None:
-                self._attr_current_option = (
-                    self.entity_description.reverse_preset_mode_map.get(mode)
-                )
-
-        self.async_write_ha_state()
-
-    async def async_select_option(self, option: str) -> None:
-        """Send the new mode via the API."""
-        mode_code = self.entity_description.preset_mode_map.get(option)
-
-        if mode_code is None:
-            _LOGGER.warning("Unknown mode selected: %s", option)
-            return
-
-        await self._api.set_device_mode(self._device["_id"], mode_code)
-        self._attr_current_option = option
-        self.async_write_ha_state()

homeassistant/components/myneomitis/strings.json

@@ -1,57 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "This integration is already configured."
-    },
-    "error": {
-      "cannot_connect": "Could not connect to the MyNeomitis service. Please try again later.",
-      "invalid_auth": "Authentication failed. Please check your email address and password.",
-      "unknown": "An unexpected error occurred. Please try again."
-    },
-    "step": {
-      "user": {
-        "data": {
-          "email": "[%key:common::config_flow::data::email%]",
-          "password": "[%key:common::config_flow::data::password%]"
-        },
-        "data_description": {
-          "email": "Your email address used for your MyNeomitis account",
-          "password": "Your MyNeomitis account password"
-        },
-        "description": "Enter your MyNeomitis account credentials.",
-        "title": "Connect to MyNeomitis"
-      }
-    }
-  },
-  "entity": {
-    "select": {
-      "pilote": {
-        "state": {
-          "antifrost": "Frost protection",
-          "auto": "[%key:common::state::auto%]",
-          "boost": "Boost",
-          "comfort": "Comfort",
-          "comfort_plus": "Comfort +",
-          "eco": "Eco",
-          "eco_1": "Eco -1",
-          "eco_2": "Eco -2",
-          "setpoint": "Setpoint",
-          "standby": "[%key:common::state::standby%]"
-        }
-      },
-      "relais": {
-        "state": {
-          "auto": "[%key:common::state::auto%]",
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]"
-        }
-      },
-      "ufh": {
-        "state": {
-          "cooling": "Cooling",
-          "heating": "Heating"
-        }
-      }
-    }
-  }
-}

homeassistant/components/ntfy/icons.json

@@ -81,9 +81,6 @@
       "service": "mdi:comment-remove"
     },
     "publish": {
-      "sections": {
-        "actions": "mdi:gesture-tap-button"
-      },
       "service": "mdi:send"
     }
   }

homeassistant/components/ntfy/notify.py

@@ -27,14 +27,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import DOMAIN
 from .coordinator import NtfyConfigEntry
 from .entity import NtfyBaseEntity
-from .services import (
-    ACTIONS_MAP,
-    ATTR_ACTION,
-    ATTR_ACTIONS,
-    ATTR_ATTACH_FILE,
-    ATTR_FILENAME,
-    ATTR_SEQUENCE_ID,
-)
+from .services import ATTR_ATTACH_FILE, ATTR_FILENAME, ATTR_SEQUENCE_ID
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -112,15 +105,6 @@ class NtfyNotifyEntity(NtfyBaseEntity, NotifyEntity):
 
                 params.setdefault(ATTR_FILENAME, media.path.name)
 
-        actions: list[dict[str, Any]] | None = params.get(ATTR_ACTIONS)
-        if actions:
-            params["actions"] = [
-                ACTIONS_MAP[action[ATTR_ACTION]](
-                    **{k: v for k, v in action.items() if k != ATTR_ACTION}
-                )
-                for action in actions
-            ]
-
         msg = Message(topic=self.topic, **params)
         try:
             await self.ntfy.publish(msg, attachment)

homeassistant/components/ntfy/services.py

@@ -3,7 +3,6 @@
 from datetime import timedelta
 from typing import Any
 
-from aiontfy import BroadcastAction, CopyAction, HttpAction, ViewAction
 import voluptuous as vol
 from yarl import URL
 
@@ -35,28 +34,6 @@ ATTR_ATTACH_FILE = "attach_file"
 ATTR_FILENAME = "filename"
 GRP_ATTACHMENT = "attachment"
 MSG_ATTACHMENT = "Only one attachment source is allowed: URL or local file"
-ATTR_ACTIONS = "actions"
-ATTR_ACTION = "action"
-ATTR_VIEW = "view"
-ATTR_BROADCAST = "broadcast"
-ATTR_HTTP = "http"
-ATTR_LABEL = "label"
-ATTR_URL = "url"
-ATTR_CLEAR = "clear"
-ATTR_INTENT = "intent"
-ATTR_EXTRAS = "extras"
-ATTR_METHOD = "method"
-ATTR_HEADERS = "headers"
-ATTR_BODY = "body"
-ATTR_VALUE = "value"
-ATTR_COPY = "copy"
-ACTIONS_MAP = {
-    ATTR_VIEW: ViewAction,
-    ATTR_BROADCAST: BroadcastAction,
-    ATTR_HTTP: HttpAction,
-    ATTR_COPY: CopyAction,
-}
-MAX_ACTIONS_ALLOWED = 3  # ntfy only supports up to 3 actions per notification
 
 
 def validate_filename(params: dict[str, Any]) -> dict[str, Any]:
@@ -68,40 +45,6 @@ def validate_filename(params: dict[str, Any]) -> dict[str, Any]:
     return params
 
 
-ACTION_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_LABEL): cv.string,
-        vol.Optional(ATTR_CLEAR, default=False): cv.boolean,
-    }
-)
-VIEW_SCHEMA = ACTION_SCHEMA.extend(
-    {
-        vol.Required(ATTR_ACTION): vol.Equal("view"),
-        vol.Required(ATTR_URL): vol.All(vol.Url(), vol.Coerce(URL)),
-    }
-)
-BROADCAST_SCHEMA = ACTION_SCHEMA.extend(
-    {
-        vol.Required(ATTR_ACTION): vol.Equal("broadcast"),
-        vol.Optional(ATTR_INTENT): cv.string,
-        vol.Optional(ATTR_EXTRAS): dict[str, str],
-    }
-)
-HTTP_SCHEMA = VIEW_SCHEMA.extend(
-    {
-        vol.Required(ATTR_ACTION): vol.Equal("http"),
-        vol.Optional(ATTR_METHOD): cv.string,
-        vol.Optional(ATTR_HEADERS): dict[str, str],
-        vol.Optional(ATTR_BODY): cv.string,
-    }
-)
-COPY_SCHEMA = ACTION_SCHEMA.extend(
-    {
-        vol.Required(ATTR_ACTION): vol.Equal("copy"),
-        vol.Required(ATTR_VALUE): cv.string,
-    }
-)
-
 SERVICE_PUBLISH_SCHEMA = vol.All(
     cv.make_entity_service_schema(
         {
@@ -126,14 +69,6 @@ SERVICE_PUBLISH_SCHEMA = vol.All(
                 ATTR_ATTACH_FILE, GRP_ATTACHMENT, MSG_ATTACHMENT
             ): MediaSelector({"accept": ["*/*"]}),
             vol.Optional(ATTR_FILENAME): cv.string,
-            vol.Optional(ATTR_ACTIONS): vol.All(
-                cv.ensure_list,
-                vol.Length(
-                    max=MAX_ACTIONS_ALLOWED,
-                    msg="Too many actions defined. A maximum of 3 is supported",
-                ),
-                [vol.Any(VIEW_SCHEMA, BROADCAST_SCHEMA, HTTP_SCHEMA, COPY_SCHEMA)],
-            ),
         }
     ),
     validate_filename,

homeassistant/components/ntfy/services.yaml

@@ -99,65 +99,6 @@ publish:
           type: url
           autocomplete: url
       example: https://example.org/logo.png
-    actions:
-      selector:
-        object:
-          label_field: "label"
-          description_field: "url"
-          multiple: true
-          translation_key: actions
-          fields:
-            action:
-              required: true
-              selector:
-                select:
-                  options:
-                    - value: view
-                      label: Open website/app
-                    - value: http
-                      label: Send HTTP request
-                    - value: broadcast
-                      label: Send Android broadcast
-                    - value: copy
-                      label: Copy to clipboard
-                  translation_key: action_type
-                  mode: dropdown
-            label:
-              selector:
-                text:
-              required: true
-            clear:
-              selector:
-                boolean:
-            url:
-              selector:
-                text:
-                  type: url
-            method:
-              selector:
-                select:
-                  options:
-                    - GET
-                    - POST
-                    - PUT
-                    - DELETE
-                  custom_value: true
-            headers:
-              selector:
-                object:
-            body:
-              selector:
-                text:
-                  multiline: true
-            intent:
-              selector:
-                text:
-            extras:
-              selector:
-                object:
-            value:
-              selector:
-                text:
     sequence_id:
       required: false
       selector:

homeassistant/components/ntfy/strings.json

@@ -318,50 +318,6 @@
     }
   },
   "selector": {
-    "actions": {
-      "fields": {
-        "action": {
-          "description": "Select the type of action to add to the notification",
-          "name": "Action type"
-        },
-        "body": {
-          "description": "The body of the HTTP request for `http` actions.",
-          "name": "HTTP body"
-        },
-        "clear": {
-          "description": "Clear notification after action button is tapped",
-          "name": "Clear notification"
-        },
-        "extras": {
-          "description": "Extras to include in the intent as key-value pairs for 'broadcast' actions",
-          "name": "Intent extras"
-        },
-        "headers": {
-          "description": "Additional HTTP headers as key-value pairs for 'http' actions",
-          "name": "HTTP headers"
-        },
-        "intent": {
-          "description": "Android intent to send when the 'broadcast' action is triggered",
-          "name": "Intent"
-        },
-        "label": {
-          "description": "Label of the action button",
-          "name": "Label"
-        },
-        "method": {
-          "description": "HTTP method to use for the 'http' action",
-          "name": "HTTP method"
-        },
-        "url": {
-          "description": "URL to open for the 'view' action or to request for the 'http' action",
-          "name": "URL"
-        },
-        "value": {
-          "description": "Value to copy to clipboard when the 'copy' action is triggered",
-          "name": "Value"
-        }
-      }
-    },
     "priority": {
       "options": {
         "1": "Minimum",
@@ -394,12 +350,8 @@
       "name": "Delete notification"
     },
     "publish": {
-      "description": "Publishes a notification message to a ntfy topic.",
+      "description": "Publishes a notification message to a ntfy topic",
       "fields": {
-        "actions": {
-          "description": "Up to three actions (`view`, `broadcast`, `http`, or `copy`) can be added as buttons below the notification. Actions are executed when the corresponding button is tapped or clicked.",
-          "name": "Action buttons"
-        },
         "attach": {
           "description": "Attach images or other files by URL.",
           "name": "Attachment URL"

homeassistant/components/overseerr/manifest.json

@@ -9,5 +9,5 @@
   "integration_type": "service",
   "iot_class": "local_push",
   "quality_scale": "platinum",
-  "requirements": ["python-overseerr==0.9.0"]
+  "requirements": ["python-overseerr==0.8.0"]
 }

homeassistant/components/overseerr/services.py

@@ -79,14 +79,6 @@ async def _async_get_requests(call: ServiceCall) -> ServiceResponse:
         req["media"] = await _get_media(
             client, request.media.media_type, request.media.tmdb_id
         )
-        for user in (req["modified_by"], req["requested_by"]):
-            del user["avatar_e_tag"]
-            del user["avatar_version"]
-            del user["permissions"]
-            del user["recovery_link_expiration_date"]
-            del user["settings"]
-            del user["user_type"]
-            del user["warnings"]
         result.append(req)
 
     return {"requests": cast(list[JsonValueType], result)}

homeassistant/components/plugwise/climate.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
+from dataclasses import dataclass
 from typing import Any
 
 from homeassistant.components.climate import (
@@ -38,7 +38,10 @@ class PlugwiseClimateExtraStoredData(ExtraStoredData):
 
     def as_dict(self) -> dict[str, Any]:
         """Return a dict representation of the text data."""
-        return asdict(self)
+        return {
+            "last_active_schedule": self.last_active_schedule,
+            "previous_action_mode": self.previous_action_mode,
+        }
 
     @classmethod
     def from_dict(cls, restored: dict[str, Any]) -> PlugwiseClimateExtraStoredData:
@@ -99,9 +102,7 @@ class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity, RestoreEntity):
                 extra_data.as_dict()
             )
             self._last_active_schedule = plugwise_extra_data.last_active_schedule
-            self._previous_action_mode = (
-                plugwise_extra_data.previous_action_mode or HVACAction.HEATING.value
-            )
+            self._previous_action_mode = plugwise_extra_data.previous_action_mode
 
     def __init__(
         self,
@@ -201,10 +202,11 @@ class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity, RestoreEntity):
 
         if self.coordinator.api.cooling_present:
             if "regulation_modes" in self._gateway_data:
-                if "heating" in self._gateway_data["regulation_modes"]:
-                    hvac_modes.append(HVACMode.HEAT)
-                if "cooling" in self._gateway_data["regulation_modes"]:
+                selected = self._gateway_data.get("select_regulation_mode")
+                if selected == HVACAction.COOLING.value:
                     hvac_modes.append(HVACMode.COOL)
+                if selected == HVACAction.HEATING.value:
+                    hvac_modes.append(HVACMode.HEAT)
             else:
                 hvac_modes.append(HVACMode.HEAT_COOL)
         else:
@@ -251,75 +253,40 @@ class PlugwiseClimateEntity(PlugwiseEntity, ClimateEntity, RestoreEntity):
 
         await self.coordinator.api.set_temperature(self._location, data)
 
-    def _regulation_mode_for_hvac(self, hvac_mode: HVACMode) -> str | None:
-        """Return the API regulation value for a manual HVAC mode, or None."""
-        if hvac_mode == HVACMode.HEAT:
-            return HVACAction.HEATING.value
-        if hvac_mode == HVACMode.COOL:
-            return HVACAction.COOLING.value
-        return None
-
     @plugwise_command
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
-        """Set the HVAC mode (off, heat, cool, heat_cool, or auto/schedule)."""
+        """Set the hvac mode."""
         if hvac_mode == self.hvac_mode:
             return
 
-        api = self.coordinator.api
-        current_schedule = self.device.get("select_schedule")
-
-        # OFF: single API call
         if hvac_mode == HVACMode.OFF:
-            await api.set_regulation_mode(hvac_mode.value)
-            return
+            await self.coordinator.api.set_regulation_mode(hvac_mode.value)
+        else:
+            current = self.device.get("select_schedule")
+            desired = current
 
-        # Manual mode (heat/cool/heat_cool) without a schedule: set regulation only
-        if (
-            current_schedule is None
-            and hvac_mode != HVACMode.AUTO
-            and (
-                regulation := self._regulation_mode_for_hvac(hvac_mode)
-                or self._previous_action_mode
-            )
-        ):
-            await api.set_regulation_mode(regulation)
-            return
+            # Capture the last valid schedule
+            if desired and desired != "off":
+                self._last_active_schedule = desired
+            elif desired == "off":
+                desired = self._last_active_schedule
 
-        # Manual mode: ensure regulation and turn off schedule when needed
-        if hvac_mode in (HVACMode.HEAT, HVACMode.COOL, HVACMode.HEAT_COOL):
-            regulation = self._regulation_mode_for_hvac(hvac_mode) or (
-                self._previous_action_mode
-                if self.hvac_mode in (HVACMode.HEAT_COOL, HVACMode.OFF)
-                else None
-            )
-            if regulation:
-                await api.set_regulation_mode(regulation)
-
-            if (
-                self.hvac_mode == HVACMode.OFF and current_schedule not in (None, "off")
-            ) or (self.hvac_mode == HVACMode.AUTO and current_schedule is not None):
-                await api.set_schedule_state(
-                    self._location, STATE_OFF, current_schedule
+            # Enabling HVACMode.AUTO requires a previously set schedule for saving and restoring
+            if hvac_mode == HVACMode.AUTO and not desired:
+                raise HomeAssistantError(
+                    translation_domain=DOMAIN,
+                    translation_key=ERROR_NO_SCHEDULE,
                 )
-            return
 
-        # AUTO: restore schedule and regulation
-        desired_schedule = current_schedule
-        if desired_schedule and desired_schedule != "off":
-            self._last_active_schedule = desired_schedule
-        elif desired_schedule == "off":
-            desired_schedule = self._last_active_schedule
-
-        if not desired_schedule:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key=ERROR_NO_SCHEDULE,
+            await self.coordinator.api.set_schedule_state(
+                self._location,
+                STATE_ON if hvac_mode == HVACMode.AUTO else STATE_OFF,
+                desired,
             )
-
-        if self._previous_action_mode:
-            if self.hvac_mode == HVACMode.OFF:
-                await api.set_regulation_mode(self._previous_action_mode)
-            await api.set_schedule_state(self._location, STATE_ON, desired_schedule)
+            if self.hvac_mode == HVACMode.OFF and self._previous_action_mode:
+                await self.coordinator.api.set_regulation_mode(
+                    self._previous_action_mode
+                )
 
     @plugwise_command
     async def async_set_preset_mode(self, preset_mode: str) -> None:

homeassistant/components/portainer/__init__.py

@@ -19,7 +19,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
 import homeassistant.helpers.config_validation as cv
 import homeassistant.helpers.device_registry as dr
-from homeassistant.helpers.device_registry import DeviceEntry
 import homeassistant.helpers.entity_registry as er
 from homeassistant.helpers.typing import ConfigType
 
@@ -138,26 +137,3 @@ async def async_migrate_entry(hass: HomeAssistant, entry: PortainerConfigEntry)
         hass.config_entries.async_update_entry(entry=entry, version=4)
 
     return True
-
-
-async def async_remove_config_entry_device(
-    hass: HomeAssistant,
-    entry: PortainerConfigEntry,
-    device: DeviceEntry,
-) -> bool:
-    """Remove a config entry from a device."""
-    coordinator = entry.runtime_data
-    valid_identifiers: set[tuple[str, str]] = set()
-
-    # The Portainer integration creates devices for both endpoints and containers. That's why we're doing it double
-    valid_identifiers.update(
-        (DOMAIN, f"{entry.entry_id}_{endpoint_id}") for endpoint_id in coordinator.data
-    )
-
-    valid_identifiers.update(
-        (DOMAIN, f"{entry.entry_id}_{container_name}")
-        for endpoint in coordinator.data.values()
-        for container_name in endpoint.containers
-    )
-
-    return not device.identifiers.intersection(valid_identifiers)

homeassistant/components/portainer/quality_scale.yaml

@@ -30,8 +30,11 @@ rules:
   entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
-  parallel-updates: done
-  reauthentication-flow: done
+  parallel-updates: todo
+  reauthentication-flow:
+    status: todo
+    comment: |
+      No reauthentication flow is defined. It will be done in a next iteration.
   test-coverage: done
   # Gold
   devices: done
@@ -44,27 +47,25 @@ rules:
     status: exempt
     comment: |
       No discovery is implemented, since it's software based.
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices: done
-  docs-supported-functions: done
-  docs-troubleshooting: done
-  docs-use-cases: done
-  dynamic-devices: done
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default: done
-  entity-translations: done
-  exception-translations: done
-  icon-translations: done
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
   reconfiguration-flow: done
-  repair-issues:
-    status: exempt
-    comment: |
-      No repair issues are implemented, currently.
-  stale-devices: done
+  repair-issues: todo
+  stale-devices: todo
+
   # Platinum
-  async-dependency: done
+  async-dependency: todo
   inject-websession: done
   strict-typing: done

homeassistant/components/powerfox/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "powerfox",
-  "name": "Powerfox Cloud",
+  "name": "Powerfox",
   "codeowners": ["@klaasnicolaas"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/powerfox",

homeassistant/components/proxmoxve/__init__.py

@@ -37,10 +37,7 @@ from .const import (
 )
 from .coordinator import ProxmoxConfigEntry, ProxmoxCoordinator
 
-PLATFORMS = [
-    Platform.BINARY_SENSOR,
-    Platform.BUTTON,
-]
+PLATFORMS = [Platform.BINARY_SENSOR]
 
 
 CONFIG_SCHEMA = vol.Schema(

homeassistant/components/proxmoxve/button.py

@@ -1,339 +0,0 @@
-"""Button platform for Proxmox VE."""
-
-from __future__ import annotations
-
-from abc import abstractmethod
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any
-
-from proxmoxer import AuthenticationError
-from proxmoxer.core import ResourceException
-import requests
-from requests.exceptions import ConnectTimeout, SSLError
-
-from homeassistant.components.button import (
-    ButtonDeviceClass,
-    ButtonEntity,
-    ButtonEntityDescription,
-)
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import DOMAIN
-from .coordinator import ProxmoxConfigEntry, ProxmoxCoordinator, ProxmoxNodeData
-from .entity import ProxmoxContainerEntity, ProxmoxNodeEntity, ProxmoxVMEntity
-
-
-@dataclass(frozen=True, kw_only=True)
-class ProxmoxNodeButtonNodeEntityDescription(ButtonEntityDescription):
-    """Class to hold Proxmox node button description."""
-
-    press_action: Callable[[ProxmoxCoordinator, str], None]
-
-
-@dataclass(frozen=True, kw_only=True)
-class ProxmoxVMButtonEntityDescription(ButtonEntityDescription):
-    """Class to hold Proxmox VM button description."""
-
-    press_action: Callable[[ProxmoxCoordinator, str, int], None]
-
-
-@dataclass(frozen=True, kw_only=True)
-class ProxmoxContainerButtonEntityDescription(ButtonEntityDescription):
-    """Class to hold Proxmox container button description."""
-
-    press_action: Callable[[ProxmoxCoordinator, str, int], None]
-
-
-NODE_BUTTONS: tuple[ProxmoxNodeButtonNodeEntityDescription, ...] = (
-    ProxmoxNodeButtonNodeEntityDescription(
-        key="reboot",
-        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
-            node
-        ).status.post(command="reboot"),
-        entity_category=EntityCategory.CONFIG,
-        device_class=ButtonDeviceClass.RESTART,
-    ),
-    ProxmoxNodeButtonNodeEntityDescription(
-        key="shutdown",
-        translation_key="shutdown",
-        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
-            node
-        ).status.post(command="shutdown"),
-        entity_category=EntityCategory.CONFIG,
-    ),
-    ProxmoxNodeButtonNodeEntityDescription(
-        key="start_all",
-        translation_key="start_all",
-        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
-            node
-        ).startall.post(),
-        entity_category=EntityCategory.CONFIG,
-    ),
-    ProxmoxNodeButtonNodeEntityDescription(
-        key="stop_all",
-        translation_key="stop_all",
-        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
-            node
-        ).stopall.post(),
-        entity_category=EntityCategory.CONFIG,
-    ),
-)
-
-VM_BUTTONS: tuple[ProxmoxVMButtonEntityDescription, ...] = (
-    ProxmoxVMButtonEntityDescription(
-        key="start",
-        translation_key="start",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).qemu(vmid).status.start.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-    ),
-    ProxmoxVMButtonEntityDescription(
-        key="stop",
-        translation_key="stop",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).qemu(vmid).status.stop.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-    ),
-    ProxmoxVMButtonEntityDescription(
-        key="restart",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).qemu(vmid).status.restart.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-        device_class=ButtonDeviceClass.RESTART,
-    ),
-    ProxmoxVMButtonEntityDescription(
-        key="hibernate",
-        translation_key="hibernate",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).qemu(vmid).status.hibernate.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-    ),
-    ProxmoxVMButtonEntityDescription(
-        key="reset",
-        translation_key="reset",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).qemu(vmid).status.reset.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-    ),
-)
-
-CONTAINER_BUTTONS: tuple[ProxmoxContainerButtonEntityDescription, ...] = (
-    ProxmoxContainerButtonEntityDescription(
-        key="start",
-        translation_key="start",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).lxc(vmid).status.start.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-    ),
-    ProxmoxContainerButtonEntityDescription(
-        key="stop",
-        translation_key="stop",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).lxc(vmid).status.stop.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-    ),
-    ProxmoxContainerButtonEntityDescription(
-        key="restart",
-        press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).lxc(vmid).status.restart.post()
-        ),
-        entity_category=EntityCategory.CONFIG,
-        device_class=ButtonDeviceClass.RESTART,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: ProxmoxConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up ProxmoxVE buttons."""
-    coordinator = entry.runtime_data
-
-    def _async_add_new_nodes(nodes: list[ProxmoxNodeData]) -> None:
-        """Add new node buttons."""
-        async_add_entities(
-            ProxmoxNodeButtonEntity(coordinator, entity_description, node)
-            for node in nodes
-            for entity_description in NODE_BUTTONS
-        )
-
-    def _async_add_new_vms(
-        vms: list[tuple[ProxmoxNodeData, dict[str, Any]]],
-    ) -> None:
-        """Add new VM buttons."""
-        async_add_entities(
-            ProxmoxVMButtonEntity(coordinator, entity_description, vm, node_data)
-            for (node_data, vm) in vms
-            for entity_description in VM_BUTTONS
-        )
-
-    def _async_add_new_containers(
-        containers: list[tuple[ProxmoxNodeData, dict[str, Any]]],
-    ) -> None:
-        """Add new container buttons."""
-        async_add_entities(
-            ProxmoxContainerButtonEntity(
-                coordinator, entity_description, container, node_data
-            )
-            for (node_data, container) in containers
-            for entity_description in CONTAINER_BUTTONS
-        )
-
-    coordinator.new_nodes_callbacks.append(_async_add_new_nodes)
-    coordinator.new_vms_callbacks.append(_async_add_new_vms)
-    coordinator.new_containers_callbacks.append(_async_add_new_containers)
-
-    _async_add_new_nodes(
-        [
-            node_data
-            for node_data in coordinator.data.values()
-            if node_data.node["node"] in coordinator.known_nodes
-        ]
-    )
-    _async_add_new_vms(
-        [
-            (node_data, vm_data)
-            for node_data in coordinator.data.values()
-            for vmid, vm_data in node_data.vms.items()
-            if (node_data.node["node"], vmid) in coordinator.known_vms
-        ]
-    )
-    _async_add_new_containers(
-        [
-            (node_data, container_data)
-            for node_data in coordinator.data.values()
-            for vmid, container_data in node_data.containers.items()
-            if (node_data.node["node"], vmid) in coordinator.known_containers
-        ]
-    )
-
-
-class ProxmoxBaseButton(ButtonEntity):
-    """Common base for Proxmox buttons. Basically to ensure the async_press logic isn't duplicated."""
-
-    entity_description: ButtonEntityDescription
-    coordinator: ProxmoxCoordinator
-
-    @abstractmethod
-    async def _async_press_call(self) -> None:
-        """Abstract method used per Proxmox button class."""
-
-    async def async_press(self) -> None:
-        """Trigger the Proxmox button press service."""
-        try:
-            await self._async_press_call()
-        except AuthenticationError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect_no_details",
-            ) from err
-        except SSLError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="invalid_auth_no_details",
-            ) from err
-        except ConnectTimeout as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="timeout_connect_no_details",
-            ) from err
-        except (ResourceException, requests.exceptions.ConnectionError) as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="api_error_no_details",
-            ) from err
-
-
-class ProxmoxNodeButtonEntity(ProxmoxNodeEntity, ProxmoxBaseButton):
-    """Represents a Proxmox Node button entity."""
-
-    entity_description: ProxmoxNodeButtonNodeEntityDescription
-
-    def __init__(
-        self,
-        coordinator: ProxmoxCoordinator,
-        entity_description: ProxmoxNodeButtonNodeEntityDescription,
-        node_data: ProxmoxNodeData,
-    ) -> None:
-        """Initialize the Proxmox Node button entity."""
-        self.entity_description = entity_description
-        super().__init__(coordinator, node_data)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{node_data.node['id']}_{entity_description.key}"
-
-    async def _async_press_call(self) -> None:
-        """Execute the node button action via executor."""
-        await self.hass.async_add_executor_job(
-            self.entity_description.press_action,
-            self.coordinator,
-            self._node_data.node["node"],
-        )
-
-
-class ProxmoxVMButtonEntity(ProxmoxVMEntity, ProxmoxBaseButton):
-    """Represents a Proxmox VM button entity."""
-
-    entity_description: ProxmoxVMButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: ProxmoxCoordinator,
-        entity_description: ProxmoxVMButtonEntityDescription,
-        vm_data: dict[str, Any],
-        node_data: ProxmoxNodeData,
-    ) -> None:
-        """Initialize the Proxmox VM button entity."""
-        self.entity_description = entity_description
-        super().__init__(coordinator, vm_data, node_data)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_id}_{entity_description.key}"
-
-    async def _async_press_call(self) -> None:
-        """Execute the VM button action via executor."""
-        await self.hass.async_add_executor_job(
-            self.entity_description.press_action,
-            self.coordinator,
-            self._node_name,
-            self.vm_data["vmid"],
-        )
-
-
-class ProxmoxContainerButtonEntity(ProxmoxContainerEntity, ProxmoxBaseButton):
-    """Represents a Proxmox Container button entity."""
-
-    entity_description: ProxmoxContainerButtonEntityDescription
-
-    def __init__(
-        self,
-        coordinator: ProxmoxCoordinator,
-        entity_description: ProxmoxContainerButtonEntityDescription,
-        container_data: dict[str, Any],
-        node_data: ProxmoxNodeData,
-    ) -> None:
-        """Initialize the Proxmox Container button entity."""
-        self.entity_description = entity_description
-        super().__init__(coordinator, container_data, node_data)
-
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_id}_{entity_description.key}"
-
-    async def _async_press_call(self) -> None:
-        """Execute the container button action via executor."""
-        await self.hass.async_add_executor_job(
-            self.entity_description.press_action,
-            self.coordinator,
-            self._node_name,
-            self.container_data["vmid"],
-        )

homeassistant/components/proxmoxve/diagnostics.py

@@ -1,28 +0,0 @@
-"""Diagnostics support for Proxmox VE."""
-
-from __future__ import annotations
-
-from dataclasses import asdict
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import HomeAssistant
-
-from . import ProxmoxConfigEntry
-
-TO_REDACT = [CONF_USERNAME, CONF_PASSWORD, CONF_HOST]
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: ProxmoxConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a Proxmox VE config entry."""
-
-    return {
-        "config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),
-        "devices": {
-            node: asdict(node_data)
-            for node, node_data in config_entry.runtime_data.data.items()
-        },
-    }