[pull] dev from home-assistant:dev

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/init@e12f0178983d466f2f6028f5cc7a6d786fd97f4b # v4.31.4
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@014f16e7ab1402f30e7c3329d33797e7948572db # v4.31.3
+        uses: github/codeql-action/analyze@e12f0178983d466f2f6028f5cc7a6d786fd97f4b # v4.31.4
         with:
           category: "/language:python"

homeassistant/components/brother/entity.py

@@ -24,7 +24,7 @@ def __init__(
             connections={(CONNECTION_NETWORK_MAC, coordinator.brother.mac)},
             serial_number=coordinator.brother.serial,
             manufacturer="Brother",
-            model=coordinator.brother.model,
+            model_id=coordinator.brother.model,
             name=coordinator.brother.model,
             sw_version=coordinator.brother.firmware,
         )

homeassistant/components/brother/sensor.py

@@ -17,7 +17,7 @@
     SensorStateClass,
 )
 from homeassistant.const import PERCENTAGE, EntityCategory
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -345,12 +345,10 @@ def __init__(
         """Initialize."""
         super().__init__(coordinator)
 
-        self._attr_native_value = description.value(coordinator.data)
         self._attr_unique_id = f"{coordinator.brother.serial.lower()}_{description.key}"
         self.entity_description = description
 
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        self._attr_native_value = self.entity_description.value(self.coordinator.data)
-        self.async_write_ha_state()
+    @property
+    def native_value(self) -> StateType | datetime:
+        """Return the native value of the sensor."""
+        return self.entity_description.value(self.coordinator.data)

homeassistant/components/config/area_registry.py

@@ -18,6 +18,7 @@ def async_setup(hass: HomeAssistant) -> bool:
     websocket_api.async_register_command(hass, websocket_create_area)
     websocket_api.async_register_command(hass, websocket_delete_area)
     websocket_api.async_register_command(hass, websocket_update_area)
+    websocket_api.async_register_command(hass, websocket_reorder_areas)
     return True
 
 
@@ -145,3 +146,27 @@ def websocket_update_area(
         connection.send_error(msg["id"], "invalid_info", str(err))
     else:
         connection.send_result(msg["id"], entry.json_fragment)
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "config/area_registry/reorder",
+        vol.Required("area_ids"): [str],
+    }
+)
+@websocket_api.require_admin
+@callback
+def websocket_reorder_areas(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Handle reorder areas websocket command."""
+    registry = ar.async_get(hass)
+
+    try:
+        registry.async_reorder(msg["area_ids"])
+    except ValueError as err:
+        connection.send_error(msg["id"], websocket_api.ERR_INVALID_FORMAT, str(err))
+    else:
+        connection.send_result(msg["id"])

homeassistant/components/config/floor_registry.py

@@ -18,6 +18,7 @@ def async_setup(hass: HomeAssistant) -> bool:
     websocket_api.async_register_command(hass, websocket_create_floor)
     websocket_api.async_register_command(hass, websocket_delete_floor)
     websocket_api.async_register_command(hass, websocket_update_floor)
+    websocket_api.async_register_command(hass, websocket_reorder_floors)
     return True
 
 
@@ -127,6 +128,28 @@ def websocket_update_floor(
         connection.send_result(msg["id"], _entry_dict(entry))
 
 
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "config/floor_registry/reorder",
+        vol.Required("floor_ids"): [str],
+    }
+)
+@websocket_api.require_admin
+@callback
+def websocket_reorder_floors(
+    hass: HomeAssistant, connection: ActiveConnection, msg: dict[str, Any]
+) -> None:
+    """Handle reorder floors websocket command."""
+    registry = fr.async_get(hass)
+
+    try:
+        registry.async_reorder(msg["floor_ids"])
+    except ValueError as err:
+        connection.send_error(msg["id"], websocket_api.ERR_INVALID_FORMAT, str(err))
+    else:
+        connection.send_result(msg["id"])
+
+
 @callback
 def _entry_dict(entry: FloorEntry) -> dict[str, Any]:
     """Convert entry to API format."""

homeassistant/components/frontend/storage.py

@@ -11,18 +11,24 @@
 from homeassistant.components import websocket_api
 from homeassistant.components.websocket_api import ActiveConnection
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import singleton
 from homeassistant.helpers.storage import Store
 from homeassistant.util.hass_dict import HassKey
 
 DATA_STORAGE: HassKey[dict[str, UserStore]] = HassKey("frontend_storage")
+DATA_SYSTEM_STORAGE: HassKey[SystemStore] = HassKey("frontend_system_storage")
 STORAGE_VERSION_USER_DATA = 1
+STORAGE_VERSION_SYSTEM_DATA = 1
 
 
 async def async_setup_frontend_storage(hass: HomeAssistant) -> None:
     """Set up frontend storage."""
     websocket_api.async_register_command(hass, websocket_set_user_data)
     websocket_api.async_register_command(hass, websocket_get_user_data)
     websocket_api.async_register_command(hass, websocket_subscribe_user_data)
+    websocket_api.async_register_command(hass, websocket_set_system_data)
+    websocket_api.async_register_command(hass, websocket_get_system_data)
+    websocket_api.async_register_command(hass, websocket_subscribe_system_data)
 
 
 async def async_user_store(hass: HomeAssistant, user_id: str) -> UserStore:
@@ -83,6 +89,52 @@ def __init__(self, hass: HomeAssistant, user_id: str) -> None:
         )
 
 
+@singleton.singleton(DATA_SYSTEM_STORAGE, async_=True)
+async def async_system_store(hass: HomeAssistant) -> SystemStore:
+    """Access the system store."""
+    store = SystemStore(hass)
+    await store.async_load()
+    return store
+
+
+class SystemStore:
+    """System store for frontend data."""
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        """Initialize the system store."""
+        self._store: Store[dict[str, Any]] = Store(
+            hass,
+            STORAGE_VERSION_SYSTEM_DATA,
+            "frontend.system_data",
+        )
+        self.data: dict[str, Any] = {}
+        self.subscriptions: dict[str, list[Callable[[], None]]] = {}
+
+    async def async_load(self) -> None:
+        """Load the data from the store."""
+        self.data = await self._store.async_load() or {}
+
+    async def async_set_item(self, key: str, value: Any) -> None:
+        """Set an item and save the store."""
+        self.data[key] = value
+        self._store.async_delay_save(lambda: self.data, 1.0)
+        for cb in self.subscriptions.get(key, []):
+            cb()
+
+    @callback
+    def async_subscribe(
+        self, key: str, on_update_callback: Callable[[], None]
+    ) -> Callable[[], None]:
+        """Subscribe to store updates."""
+        self.subscriptions.setdefault(key, []).append(on_update_callback)
+
+        def unsubscribe() -> None:
+            """Unsubscribe from the store."""
+            self.subscriptions[key].remove(on_update_callback)
+
+        return unsubscribe
+
+
 def with_user_store(
     orig_func: Callable[
         [HomeAssistant, ActiveConnection, dict[str, Any], UserStore],
@@ -107,6 +159,28 @@ async def with_user_store_func(
     return with_user_store_func
 
 
+def with_system_store(
+    orig_func: Callable[
+        [HomeAssistant, ActiveConnection, dict[str, Any], SystemStore],
+        Coroutine[Any, Any, None],
+    ],
+) -> Callable[
+    [HomeAssistant, ActiveConnection, dict[str, Any]], Coroutine[Any, Any, None]
+]:
+    """Decorate function to provide system store."""
+
+    @wraps(orig_func)
+    async def with_system_store_func(
+        hass: HomeAssistant, connection: ActiveConnection, msg: dict[str, Any]
+    ) -> None:
+        """Provide system store to function."""
+        store = await async_system_store(hass)
+
+        await orig_func(hass, connection, msg, store)
+
+    return with_system_store_func
+
+
 @websocket_api.websocket_command(
     {
         vol.Required("type"): "frontend/set_user_data",
@@ -169,3 +243,65 @@ def on_data_update() -> None:
     connection.subscriptions[msg["id"]] = store.async_subscribe(key, on_data_update)
     on_data_update()
     connection.send_result(msg["id"])
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "frontend/set_system_data",
+        vol.Required("key"): str,
+        vol.Required("value"): vol.Any(bool, str, int, float, dict, list, None),
+    }
+)
+@websocket_api.require_admin
+@websocket_api.async_response
+@with_system_store
+async def websocket_set_system_data(
+    hass: HomeAssistant,
+    connection: ActiveConnection,
+    msg: dict[str, Any],
+    store: SystemStore,
+) -> None:
+    """Handle set system data command."""
+    await store.async_set_item(msg["key"], msg["value"])
+    connection.send_result(msg["id"])
+
+
+@websocket_api.websocket_command(
+    {vol.Required("type"): "frontend/get_system_data", vol.Required("key"): str}
+)
+@websocket_api.async_response
+@with_system_store
+async def websocket_get_system_data(
+    hass: HomeAssistant,
+    connection: ActiveConnection,
+    msg: dict[str, Any],
+    store: SystemStore,
+) -> None:
+    """Handle get system data command."""
+    connection.send_result(msg["id"], {"value": store.data.get(msg["key"])})
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "frontend/subscribe_system_data",
+        vol.Required("key"): str,
+    }
+)
+@websocket_api.async_response
+@with_system_store
+async def websocket_subscribe_system_data(
+    hass: HomeAssistant,
+    connection: ActiveConnection,
+    msg: dict[str, Any],
+    store: SystemStore,
+) -> None:
+    """Handle subscribe to system data command."""
+    key: str = msg["key"]
+
+    def on_data_update() -> None:
+        """Handle system data update."""
+        connection.send_event(msg["id"], {"value": store.data.get(key)})
+
+    connection.subscriptions[msg["id"]] = store.async_subscribe(key, on_data_update)
+    on_data_update()
+    connection.send_result(msg["id"])

homeassistant/components/homeassistant_hardware/manifest.json

@@ -7,7 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_hardware",
   "integration_type": "system",
   "requirements": [
-    "universal-silabs-flasher==0.1.0",
+    "universal-silabs-flasher==0.1.2",
     "ha-silabs-firmware-client==0.3.0"
   ]
 }

homeassistant/components/lamarzocco/coordinator.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
+from asyncio import Task
 from dataclasses import dataclass
 from datetime import timedelta
 import logging
@@ -44,7 +45,7 @@ class LaMarzoccoUpdateCoordinator(DataUpdateCoordinator[None]):
 
     _default_update_interval = SCAN_INTERVAL
     config_entry: LaMarzoccoConfigEntry
-    websocket_terminated = True
+    _websocket_task: Task | None = None
 
     def __init__(
         self,
@@ -64,6 +65,13 @@ def __init__(
         self.device = device
         self.cloud_client = cloud_client
 
+    @property
+    def websocket_terminated(self) -> bool:
+        """Return True if the websocket task is terminated or not running."""
+        if self._websocket_task is None:
+            return True
+        return self._websocket_task.done()
+
     async def _async_update_data(self) -> None:
         """Do the data update."""
         try:
@@ -95,13 +103,14 @@ async def _internal_async_update_data(self) -> None:
         # ensure token stays valid; does nothing if token is still valid
         await self.cloud_client.async_get_access_token()
 
-        if self.device.websocket.connected:
+        # Only skip websocket reconnection if it's currently connected and the task is still running
+        if self.device.websocket.connected and not self.websocket_terminated:
             return
 
         await self.device.get_dashboard()
         _LOGGER.debug("Current status: %s", self.device.dashboard.to_dict())
 
-        self.config_entry.async_create_background_task(
+        self._websocket_task = self.config_entry.async_create_background_task(
             hass=self.hass,
             target=self.connect_websocket(),
             name="lm_websocket_task",
@@ -120,7 +129,6 @@ async def connect_websocket(self) -> None:
 
         _LOGGER.debug("Init WebSocket in background task")
 
-        self.websocket_terminated = False
         self.async_update_listeners()
 
         await self.device.connect_dashboard_websocket(
@@ -129,7 +137,6 @@ async def connect_websocket(self) -> None:
             disconnect_callback=self.async_update_listeners,
         )
 
-        self.websocket_terminated = True
         self.async_update_listeners()
 
 

homeassistant/components/onedrive/manifest.json

@@ -10,5 +10,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["onedrive_personal_sdk"],
   "quality_scale": "platinum",
-  "requirements": ["onedrive-personal-sdk==0.0.16"]
+  "requirements": ["onedrive-personal-sdk==0.0.17"]
 }

homeassistant/components/tuya/sensor.py

@@ -851,11 +851,16 @@ class TuyaSensorEntityDescription(SensorEntityDescription):
             key=DPCode.EXCRETION_TIME_DAY,
             translation_key="excretion_time_day",
             device_class=SensorDeviceClass.DURATION,
+            state_class=SensorStateClass.MEASUREMENT,
         ),
         TuyaSensorEntityDescription(
             key=DPCode.EXCRETION_TIMES_DAY,
             translation_key="excretion_times_day",
         ),
+        TuyaSensorEntityDescription(
+            key=DPCode.STATUS,
+            translation_key="cat_litter_box_status",
+        ),
     ),
     DeviceCategory.MZJ: (
         TuyaSensorEntityDescription(