[pull] dev from home-assistant:dev

.github/copilot-instructions.md

@@ -96,8 +96,14 @@ rules:
 - **coordinator.py**: Centralize data fetching logic
   ```python
   class MyCoordinator(DataUpdateCoordinator[MyData]):
-      def __init__(self, hass: HomeAssistant, client: MyClient) -> None:
-          super().__init__(hass, logger=LOGGER, name=DOMAIN, update_interval=timedelta(minutes=1))
+      def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+          super().__init__(
+              hass, 
+              logger=LOGGER, 
+              name=DOMAIN, 
+              update_interval=timedelta(minutes=1),
+              config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+          )
   ```
 - **entity.py**: Base entity definitions to reduce duplication
   ```python
@@ -203,13 +209,24 @@ rules:
 - **Standard Pattern**: Use for efficient data management
   ```python
   class MyCoordinator(DataUpdateCoordinator):
+      def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+          super().__init__(
+              hass,
+              logger=LOGGER,
+              name=DOMAIN,
+              update_interval=timedelta(minutes=5),
+              config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+          )
+          self.client = client
+
       async def _async_update_data(self):
           try:
-              return await self.api.fetch_data()
+              return await self.client.fetch_data()
           except ApiError as err:
               raise UpdateFailed(f"API communication error: {err}")
   ```
 - **Error Types**: Use `UpdateFailed` for API errors, `ConfigEntryAuthFailed` for auth issues
+- **Config Entry**: Always pass `config_entry` parameter to coordinator - it's accepted and recommended
 
 ## Integration Guidelines
 
@@ -220,6 +237,10 @@ rules:
   - Connection-critical config: Store in `ConfigEntry.data`
   - Non-critical settings: Store in `ConfigEntry.options`
 - **Validation**: Always validate user input before creating entries
+- **Config Entry Naming**: 
+  - ❌ Do NOT allow users to set config entry names in config flows
+  - Names are automatically generated or can be customized later in UI
+  - ✅ Exception: Helper integrations MAY allow custom names in config flow
 - **Connection Testing**: Test device/service connection during config flow:
   ```python
   try:
@@ -366,7 +387,8 @@ rules:
 
 ### Polling
 - Use update coordinator pattern when possible
-- Polling intervals are NOT user-configurable
+- **Polling intervals are NOT user-configurable**: Never add scan_interval, update_interval, or polling frequency options to config flows or config entries
+- **Integration determines intervals**: Set `update_interval` programmatically based on integration logic, not user input
 - **Minimum Intervals**:
   - Local network: 5 seconds
   - Cloud services: 60 seconds
@@ -384,6 +406,57 @@ rules:
   - `ConfigEntryNotReady`: Temporary setup issues (device offline)
   - `ConfigEntryAuthFailed`: Authentication problems
   - `ConfigEntryError`: Permanent setup issues
+- **Try/Catch Best Practices**:
+  - Only wrap code that can throw exceptions
+  - Keep try blocks minimal - process data after the try/catch
+  - **Avoid bare exceptions** except in specific cases:
+    - ❌ Generally not allowed: `except:` or `except Exception:`
+    - ✅ Allowed in config flows to ensure robustness
+    - ✅ Allowed in functions/methods that run in background tasks
+  - Bad pattern:
+    ```python
+    try:
+        data = await device.get_data()  # Can throw
+        # ❌ Don't process data inside try block
+        processed = data.get("value", 0) * 100
+        self._attr_native_value = processed
+    except DeviceError:
+        _LOGGER.error("Failed to get data")
+    ```
+  - Good pattern:
+    ```python
+    try:
+        data = await device.get_data()  # Can throw
+    except DeviceError:
+        _LOGGER.error("Failed to get data")
+        return
+
+    # ✅ Process data outside try block
+    processed = data.get("value", 0) * 100
+    self._attr_native_value = processed
+    ```
+- **Bare Exception Usage**:
+  ```python
+  # ❌ Not allowed in regular code
+  try:
+      data = await device.get_data()
+  except Exception:  # Too broad
+      _LOGGER.error("Failed")
+
+  # ✅ Allowed in config flow for robustness
+  async def async_step_user(self, user_input=None):
+      try:
+          await self._test_connection(user_input)
+      except Exception:  # Allowed here
+          errors["base"] = "unknown"
+
+  # ✅ Allowed in background tasks
+  async def _background_refresh():
+      try:
+          await coordinator.async_refresh()
+      except Exception:  # Allowed in task
+          _LOGGER.exception("Unexpected error in background task")
+  ```
 - **Setup Failure Patterns**:
   ```python
   try:
@@ -445,6 +518,30 @@ rules:
 - Device names
 - Email addresses, usernames
 
+### Entity Descriptions
+- **Lambda/Anonymous Functions**: Often used in EntityDescription for value transformation
+- **Multiline Lambdas**: When lambdas exceed line length, wrap in parentheses for readability
+- **Bad pattern**:
+  ```python
+  SensorEntityDescription(
+      key="temperature",
+      name="Temperature",
+      value_fn=lambda data: round(data["temp_value"] * 1.8 + 32, 1) if data.get("temp_value") is not None else None,  # ❌ Too long
+  )
+  ```
+- **Good pattern**:
+  ```python
+  SensorEntityDescription(
+      key="temperature", 
+      name="Temperature",
+      value_fn=lambda data: (  # ✅ Parenthesis on same line as lambda
+          round(data["temp_value"] * 1.8 + 32, 1)
+          if data.get("temp_value") is not None
+          else None
+      ),
+  )
+  ```
+
 ### Entity Naming
 - **Use has_entity_name**: Set `_attr_has_entity_name = True`
 - **For specific fields**:
@@ -846,6 +943,31 @@ return {"api_key": entry.data[CONF_API_KEY]}  # ❌ Exposes secrets
 
 # Accessing hass.data directly in tests
 coordinator = hass.data[DOMAIN][entry.entry_id]  # ❌ Don't access hass.data
+
+# User-configurable polling intervals
+# In config flow
+vol.Optional("scan_interval", default=60): cv.positive_int  # ❌ Not allowed
+# In coordinator
+update_interval = timedelta(minutes=entry.data.get("scan_interval", 1))  # ❌ Not allowed
+
+# User-configurable config entry names (non-helper integrations)
+vol.Optional("name", default="My Device"): cv.string  # ❌ Not allowed in regular integrations
+
+# Too much code in try block
+try:
+    response = await client.get_data()  # Can throw
+    # ❌ Data processing should be outside try block
+    temperature = response["temperature"] / 10
+    humidity = response["humidity"] 
+    self._attr_native_value = temperature
+except ClientError:
+    _LOGGER.error("Failed to fetch data")
+
+# Bare exceptions in regular code
+try:
+    value = await sensor.read_value()
+except Exception:  # ❌ Too broad - catch specific exceptions
+    _LOGGER.error("Failed to read sensor")
 ```
 
 ### ✅ **Use These Patterns Instead**
@@ -875,6 +997,21 @@ return async_redact_data(data, {"api_key", "password"})  # ✅ Safe
 async def init_integration(hass, mock_config_entry, mock_api):
     mock_config_entry.add_to_hass(hass)
     await hass.config_entries.async_setup(mock_config_entry.entry_id)  # ✅ Proper setup
+
+# Integration-determined polling intervals (not user-configurable)
+SCAN_INTERVAL = timedelta(minutes=5)  # ✅ Common pattern: constant in const.py
+
+class MyCoordinator(DataUpdateCoordinator[MyData]):
+    def __init__(self, hass: HomeAssistant, client: MyClient, config_entry: ConfigEntry) -> None:
+        # ✅ Integration determines interval based on device capabilities, connection type, etc.
+        interval = timedelta(minutes=1) if client.is_local else SCAN_INTERVAL
+        super().__init__(
+            hass, 
+            logger=LOGGER, 
+            name=DOMAIN, 
+            update_interval=interval,
+            config_entry=config_entry,  # ✅ Pass config_entry - it's accepted and recommended
+        )
 ```
 
 ### Entity Performance Optimization

homeassistant/components/devolo_home_control/entity.py

@@ -9,7 +9,7 @@
 from devolo_home_control_api.homecontrol import HomeControl
 
 from homeassistant.components.sensor import SensorDeviceClass
-from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.entity import Entity
 
 from .const import DOMAIN
@@ -35,7 +35,7 @@ def __init__(
         )  # This is not doing I/O. It fetches an internal state of the API
         self._attr_should_poll = False
         self._attr_unique_id = element_uid
-        self._attr_device_info = DeviceInfo(
+        self._attr_device_info = dr.DeviceInfo(
             configuration_url=f"https://{urlparse(device_instance.href).netloc}",
             identifiers={(DOMAIN, self._device_instance.uid)},
             manufacturer=device_instance.brand,
@@ -88,6 +88,16 @@ def _generic_message(self, message: tuple) -> None:
         elif len(message) == 3 and message[2] == "status":
             # Maybe the API wants to tell us, that the device went on- or offline.
             self._attr_available = self._device_instance.is_online()
+        elif message[1] == "del" and self.platform.config_entry:
+            device_registry = dr.async_get(self.hass)
+            device = device_registry.async_get_device(
+                identifiers={(DOMAIN, self._device_instance.uid)}
+            )
+            if device:
+                device_registry.async_update_device(
+                    device.id,
+                    remove_config_entry_id=self.platform.config_entry.entry_id,
+                )
         else:
             _LOGGER.debug("No valid message received: %s", message)
 

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -7,7 +7,10 @@
 import logging
 from typing import Any
 
-from ha_silabs_firmware_client import FirmwareUpdateClient
+from aiohttp import ClientError
+from ha_silabs_firmware_client import FirmwareUpdateClient, ManifestMissing
+from universal_silabs_flasher.common import Version
+from universal_silabs_flasher.firmware import NabuCasaMetadata
 
 from homeassistant.components.hassio import (
     AddonError,
@@ -149,15 +152,78 @@ async def _install_firmware_step(
         assert self._device is not None
 
         if not self.firmware_install_task:
+            # We 100% need to install new firmware only if the wrong firmware is
+            # currently installed
+            firmware_install_required = self._probed_firmware_info is None or (
+                self._probed_firmware_info.firmware_type
+                != expected_installed_firmware_type
+            )
+
             session = async_get_clientsession(self.hass)
             client = FirmwareUpdateClient(fw_update_url, session)
-            manifest = await client.async_update_data()
 
-            fw_meta = next(
-                fw for fw in manifest.firmwares if fw.filename.startswith(fw_type)
-            )
+            try:
+                manifest = await client.async_update_data()
+                fw_manifest = next(
+                    fw for fw in manifest.firmwares if fw.filename.startswith(fw_type)
+                )
+            except (StopIteration, TimeoutError, ClientError, ManifestMissing) as err:
+                _LOGGER.warning(
+                    "Failed to fetch firmware update manifest", exc_info=True
+                )
+
+                # Not having internet access should not prevent setup
+                if not firmware_install_required:
+                    _LOGGER.debug(
+                        "Skipping firmware upgrade due to index download failure"
+                    )
+                    return self.async_show_progress_done(next_step_id=next_step_id)
+
+                raise AbortFlow(
+                    "fw_download_failed",
+                    description_placeholders={
+                        **self._get_translation_placeholders(),
+                        "firmware_name": firmware_name,
+                    },
+                ) from err
+
+            if not firmware_install_required:
+                assert self._probed_firmware_info is not None
+
+                # Make sure we do not downgrade the firmware
+                fw_metadata = NabuCasaMetadata.from_json(fw_manifest.metadata)
+                fw_version = fw_metadata.get_public_version()
+                probed_fw_version = Version(self._probed_firmware_info.firmware_version)
+
+                if probed_fw_version >= fw_version:
+                    _LOGGER.debug(
+                        "Not downgrading firmware, installed %s is newer than available %s",
+                        probed_fw_version,
+                        fw_version,
+                    )
+                    return self.async_show_progress_done(next_step_id=next_step_id)
+
+            try:
+                fw_data = await client.async_fetch_firmware(fw_manifest)
+            except (TimeoutError, ClientError, ValueError) as err:
+                _LOGGER.warning("Failed to fetch firmware update", exc_info=True)
+
+                # If we cannot download new firmware, we shouldn't block setup
+                if not firmware_install_required:
+                    _LOGGER.debug(
+                        "Skipping firmware upgrade due to image download failure"
+                    )
+                    return self.async_show_progress_done(next_step_id=next_step_id)
+
+                # Otherwise, fail
+                raise AbortFlow(
+                    "fw_download_failed",
+                    description_placeholders={
+                        **self._get_translation_placeholders(),
+                        "firmware_name": firmware_name,
+                    },
+                ) from err
 
-            fw_data = await client.async_fetch_firmware(fw_meta)
             self.firmware_install_task = self.hass.async_create_task(
                 async_flash_silabs_firmware(
                     hass=self.hass,
@@ -215,6 +281,14 @@ async def async_step_addon_operation_failed(
             },
         )
 
+    async def async_step_pre_confirm_zigbee(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Pre-confirm Zigbee setup."""
+
+        # This step is necessary to prevent `user_input` from being passed through
+        return await self.async_step_confirm_zigbee()
+
     async def async_step_confirm_zigbee(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -409,7 +483,15 @@ async def async_step_start_otbr_addon(
         finally:
             self.addon_start_task = None
 
-        return self.async_show_progress_done(next_step_id="confirm_otbr")
+        return self.async_show_progress_done(next_step_id="pre_confirm_otbr")
+
+    async def async_step_pre_confirm_otbr(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Pre-confirm OTBR setup."""
+
+        # This step is necessary to prevent `user_input` from being passed through
+        return await self.async_step_confirm_otbr()
 
     async def async_step_confirm_otbr(
         self, user_input: dict[str, Any] | None = None

homeassistant/components/homeassistant_hardware/strings.json

@@ -36,7 +36,8 @@
         "otbr_addon_already_running": "The OpenThread Border Router add-on is already running, it cannot be installed again.",
         "zha_still_using_stick": "This {model} is in use by the Zigbee Home Automation integration. Please migrate your Zigbee network to another adapter or delete the integration and try again.",
         "otbr_still_using_stick": "This {model} is in use by the OpenThread Border Router add-on. If you use the Thread network, make sure you have alternative border routers. Uninstall the add-on and try again.",
-        "unsupported_firmware": "The radio firmware on your {model} could not be determined. Make sure that no other integration or add-on is currently trying to communicate with the device. If you are running Home Assistant OS in a virtual machine or in Docker, please make sure that permissions are set correctly for the device."
+        "unsupported_firmware": "The radio firmware on your {model} could not be determined. Make sure that no other integration or add-on is currently trying to communicate with the device. If you are running Home Assistant OS in a virtual machine or in Docker, please make sure that permissions are set correctly for the device.",
+        "fw_download_failed": "{firmware_name} firmware for your {model} failed to download. Make sure Home Assistant has internet access and try again."
       },
       "progress": {
         "install_firmware": "Please wait while {firmware_name} firmware is installed to your {model}, this will take a few minutes. Do not make any changes to your hardware or software until this finishes."

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -93,7 +93,7 @@ async def async_step_install_zigbee_firmware(
             firmware_name="Zigbee",
             expected_installed_firmware_type=ApplicationType.EZSP,
             step_id="install_zigbee_firmware",
-            next_step_id="confirm_zigbee",
+            next_step_id="pre_confirm_zigbee",
         )
 
     async def async_step_install_thread_firmware(