[pull] dev from home-assistant:dev

.github/copilot-instructions.md

@@ -1073,7 +1073,11 @@ async def test_flow_connection_error(hass, mock_api_error):
 
 ### Entity Testing Patterns
 ```python
-@pytest.mark.parametrize("init_integration", [Platform.SENSOR], indirect=True)
+@pytest.fixture 
+def platforms() -> list[Platform]: 
+    """Overridden fixture to specify platforms to test.""" 
+    return [Platform.SENSOR]  # Or another specific platform as needed.
+
 @pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
 async def test_entities(
     hass: HomeAssistant,
@@ -1120,16 +1124,25 @@ def mock_device_api() -> Generator[MagicMock]:
         )
         yield api
 
+@pytest.fixture 
+def platforms() -> list[Platform]: 
+    """Fixture to specify platforms to test.""" 
+    return PLATFORMS
+
 @pytest.fixture
 async def init_integration(
     hass: HomeAssistant,
     mock_config_entry: MockConfigEntry,
     mock_device_api: MagicMock,
+    platforms: list[Platform],
 ) -> MockConfigEntry:
     """Set up the integration for testing."""
     mock_config_entry.add_to_hass(hass)
-    await hass.config_entries.async_setup(mock_config_entry.entry_id)
-    await hass.async_block_till_done()
+
+    with patch("homeassistant.components.my_integration.PLATFORMS", platforms):
+        await hass.config_entries.async_setup(mock_config_entry.entry_id)
+        await hass.async_block_till_done()
+
     return mock_config_entry
 ```
 

homeassistant/components/bluetooth/manifest.json

@@ -16,7 +16,7 @@
   "quality_scale": "internal",
   "requirements": [
     "bleak==1.0.1",
-    "bleak-retry-connector==4.3.0",
+    "bleak-retry-connector==4.4.1",
     "bluetooth-adapters==2.0.0",
     "bluetooth-auto-recovery==1.5.2",
     "bluetooth-data-tools==1.28.2",

homeassistant/components/ccm15/climate.py

@@ -3,9 +3,10 @@
 import logging
 from typing import Any
 
-from ccm15 import CCM15DeviceState
+from ccm15 import CCM15DeviceState, CCM15SlaveDevice
 
 from homeassistant.components.climate import (
+    ATTR_HVAC_MODE,
     FAN_AUTO,
     FAN_HIGH,
     FAN_LOW,
@@ -88,7 +89,7 @@ def __init__(
         )
 
     @property
-    def data(self) -> CCM15DeviceState | None:
+    def data(self) -> CCM15SlaveDevice | None:
         """Return device data."""
         return self.coordinator.get_ac_data(self._ac_index)
 
@@ -144,15 +145,17 @@ def extra_state_attributes(self) -> dict[str, Any]:
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set the target temperature."""
         if (temperature := kwargs.get(ATTR_TEMPERATURE)) is not None:
-            await self.coordinator.async_set_temperature(self._ac_index, temperature)
+            await self.coordinator.async_set_temperature(
+                self._ac_index, self.data, temperature, kwargs.get(ATTR_HVAC_MODE)
+            )
 
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set the hvac mode."""
-        await self.coordinator.async_set_hvac_mode(self._ac_index, hvac_mode)
+        await self.coordinator.async_set_hvac_mode(self._ac_index, self.data, hvac_mode)
 
     async def async_set_fan_mode(self, fan_mode: str) -> None:
         """Set the fan mode."""
-        await self.coordinator.async_set_fan_mode(self._ac_index, fan_mode)
+        await self.coordinator.async_set_fan_mode(self._ac_index, self.data, fan_mode)
 
     async def async_turn_off(self) -> None:
         """Turn off."""

homeassistant/components/ccm15/coordinator.py

@@ -55,9 +55,9 @@ async def _fetch_data(self) -> CCM15DeviceState:
         """Get the current status of all AC devices."""
         return await self._ccm15.get_status_async()
 
-    async def async_set_state(self, ac_index: int, state: str, value: int) -> None:
+    async def async_set_state(self, ac_index: int, data) -> None:
         """Set new target states."""
-        if await self._ccm15.async_set_state(ac_index, state, value):
+        if await self._ccm15.async_set_state(ac_index, data):
             await self.async_request_refresh()
 
     def get_ac_data(self, ac_index: int) -> CCM15SlaveDevice | None:
@@ -67,17 +67,32 @@ def get_ac_data(self, ac_index: int) -> CCM15SlaveDevice | None:
             return None
         return self.data.devices[ac_index]
 
-    async def async_set_hvac_mode(self, ac_index, hvac_mode: HVACMode) -> None:
-        """Set the hvac mode."""
+    async def async_set_hvac_mode(
+        self, ac_index: int, data: CCM15SlaveDevice, hvac_mode: HVACMode
+    ) -> None:
+        """Set the HVAC mode."""
         _LOGGER.debug("Set Hvac[%s]='%s'", ac_index, str(hvac_mode))
-        await self.async_set_state(ac_index, "mode", CONST_STATE_CMD_MAP[hvac_mode])
+        data.ac_mode = CONST_STATE_CMD_MAP[hvac_mode]
+        await self.async_set_state(ac_index, data)
 
-    async def async_set_fan_mode(self, ac_index, fan_mode: str) -> None:
+    async def async_set_fan_mode(
+        self, ac_index: int, data: CCM15SlaveDevice, fan_mode: str
+    ) -> None:
         """Set the fan mode."""
         _LOGGER.debug("Set Fan[%s]='%s'", ac_index, fan_mode)
-        await self.async_set_state(ac_index, "fan", CONST_FAN_CMD_MAP[fan_mode])
-
-    async def async_set_temperature(self, ac_index, temp) -> None:
+        data.fan_mode = CONST_FAN_CMD_MAP[fan_mode]
+        await self.async_set_state(ac_index, data)
+
+    async def async_set_temperature(
+        self,
+        ac_index: int,
+        data: CCM15SlaveDevice,
+        temp: int,
+        hvac_mode: HVACMode | None,
+    ) -> None:
         """Set the target temperature mode."""
         _LOGGER.debug("Set Temp[%s]='%s'", ac_index, temp)
-        await self.async_set_state(ac_index, "temp", temp)
+        data.temperature_setpoint = temp
+        if hvac_mode is not None:
+            data.ac_mode = CONST_STATE_CMD_MAP[hvac_mode]
+        await self.async_set_state(ac_index, data)

homeassistant/components/ccm15/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/ccm15",
   "iot_class": "local_polling",
-  "requirements": ["py-ccm15==0.0.9"]
+  "requirements": ["py_ccm15==0.1.2"]
 }

homeassistant/components/husqvarna_automower/coordinator.py

@@ -62,6 +62,7 @@ def __init__(
         self.new_areas_callbacks: list[Callable[[str, set[int]], None]] = []
         self.pong: datetime | None = None
         self.websocket_alive: bool = False
+        self.websocket_callbacks: list[Callable[[bool], None]] = []
         self._watchdog_task: asyncio.Task | None = None
 
     @override
@@ -198,12 +199,17 @@ def _should_poll(self) -> bool:
         )
 
     async def _pong_watchdog(self) -> None:
+        """Watchdog to check for pong messages."""
         _LOGGER.debug("Watchdog started")
         try:
             while True:
                 _LOGGER.debug("Sending ping")
-                self.websocket_alive = await self.api.send_empty_message()
-                _LOGGER.debug("Ping result: %s", self.websocket_alive)
+                is_alive = await self.api.send_empty_message()
+                _LOGGER.debug("Ping result: %s", is_alive)
+                if self.websocket_alive != is_alive:
+                    self.websocket_alive = is_alive
+                    for ws_callback in self.websocket_callbacks:
+                        ws_callback(is_alive)
 
                 await asyncio.sleep(PING_INTERVAL)
                 _LOGGER.debug("Websocket alive %s", self.websocket_alive)

homeassistant/components/husqvarna_automower/event.py

@@ -1,6 +1,7 @@
 """Creates the event entities for supported mowers."""
 
 from collections.abc import Callable
+import logging
 
 from aioautomower.model import SingleMessageData
 
@@ -18,6 +19,7 @@
 from .coordinator import AutomowerDataUpdateCoordinator
 from .entity import AutomowerBaseEntity
 
+_LOGGER = logging.getLogger(__name__)
 PARALLEL_UPDATES = 1
 
 ATTR_SEVERITY = "severity"
@@ -80,6 +82,12 @@ def __init__(
         """Initialize Automower message event entity."""
         super().__init__(mower_id, coordinator)
         self._attr_unique_id = f"{mower_id}_message"
+        self.websocket_alive: bool = coordinator.websocket_alive
+
+    @property
+    def available(self) -> bool:
+        """Return True if the entity is available."""
+        return self.websocket_alive and self.mower_id in self.coordinator.data
 
     @callback
     def _handle(self, msg: SingleMessageData) -> None:
@@ -102,7 +110,17 @@ async def async_added_to_hass(self) -> None:
         """Register callback when entity is added to hass."""
         await super().async_added_to_hass()
         self.coordinator.api.register_single_message_callback(self._handle)
+        self.coordinator.websocket_callbacks.append(self._handle_websocket_update)
 
     async def async_will_remove_from_hass(self) -> None:
         """Unregister WebSocket callback when entity is removed."""
         self.coordinator.api.unregister_single_message_callback(self._handle)
+        self.coordinator.websocket_callbacks.remove(self._handle_websocket_update)
+
+    def _handle_websocket_update(self, is_alive: bool) -> None:
+        """Handle websocket status changes."""
+        if self.websocket_alive == is_alive:
+            return
+        self.websocket_alive = is_alive
+        _LOGGER.debug("WebSocket status changed to %s, updating entity state", is_alive)
+        self.async_write_ha_state()

homeassistant/components/husqvarna_automower/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["aioautomower"],
   "quality_scale": "silver",
-  "requirements": ["aioautomower==2.1.2"]
+  "requirements": ["aioautomower==2.2.0"]
 }

homeassistant/components/husqvarna_automower_ble/__init__.py

@@ -9,11 +9,11 @@
 
 from homeassistant.components import bluetooth
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_ADDRESS, CONF_CLIENT_ID, Platform
+from homeassistant.const import CONF_ADDRESS, CONF_CLIENT_ID, CONF_PIN, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 
-from .const import LOGGER
+from .const import DOMAIN, LOGGER
 from .coordinator import HusqvarnaCoordinator
 
 type HusqvarnaConfigEntry = ConfigEntry[HusqvarnaCoordinator]
@@ -26,10 +26,18 @@
 
 async def async_setup_entry(hass: HomeAssistant, entry: HusqvarnaConfigEntry) -> bool:
     """Set up Husqvarna Autoconnect Bluetooth from a config entry."""
+    if CONF_PIN not in entry.data:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="pin_required",
+            translation_placeholders={"domain_name": "Husqvarna Automower BLE"},
+        )
+
     address = entry.data[CONF_ADDRESS]
+    pin = int(entry.data[CONF_PIN])
     channel_id = entry.data[CONF_CLIENT_ID]
 
-    mower = Mower(channel_id, address)
+    mower = Mower(channel_id, address, pin)
 
     await close_stale_connections_by_address(address)
 
@@ -39,6 +47,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: HusqvarnaConfigEntry) ->
             hass, address, connectable=True
         ) or await get_device(address)
         response_result = await mower.connect(device)
+        if response_result == ResponseResult.INVALID_PIN:
+            raise ConfigEntryAuthFailed(
+                f"Unable to connect to device {address} due to wrong PIN"
+            )
         if response_result != ResponseResult.OK:
             raise ConfigEntryNotReady(
                 f"Unable to connect to device {address}, mower returned {response_result}"