add tests for the switch platform

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/builder.yml

@@ -27,7 +27,7 @@ jobs:
       publish: ${{ steps.version.outputs.publish }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
         with:
           fetch-depth: 0
 
@@ -88,13 +88,9 @@ jobs:
       fail-fast: false
       matrix:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
-        exclude:
-          - arch: armv7
-          - arch: armhf
-          - arch: i386
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
@@ -227,7 +223,7 @@ jobs:
           - green
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Set build additional args
         run: |
@@ -265,7 +261,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Initialize git
         uses: home-assistant/actions/helpers/git-init@master
@@ -309,7 +305,7 @@ jobs:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Cosign
         uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
@@ -418,7 +414,7 @@ jobs:
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
@@ -463,7 +459,7 @@ jobs:
       HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Login to GitHub Container Registry
         uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0

.github/workflows/ci.yaml

@@ -99,7 +99,7 @@ jobs:
     steps:
       - &checkout
         name: Check out code from GitHub
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
       - name: Generate partial Python venv restore key
         id: generate_python_cache_key
         run: |

.github/workflows/codeql.yml

@@ -21,14 +21,14 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - 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"

.github/workflows/translations.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0

.github/workflows/wheels.yml

@@ -33,7 +33,7 @@ jobs:
     steps:
       - &checkout
         name: Checkout the repository
-        uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1
+        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
@@ -77,20 +77,8 @@ jobs:
 
             # Use C-Extension for SQLAlchemy
             echo "REQUIRE_SQLALCHEMY_CEXT=1"
-
-            # Add additional pip wheel build constraints
-            echo "PIP_CONSTRAINT=build_constraints.txt"
           ) > .env_file
 
-      - name: Write pip wheel build constraints
-        run: |
-          (
-            # ninja 1.11.1.2 + 1.11.1.3 seem to be broken on at least armhf
-            # this caused the numpy builds to fail
-            # https://github.com/scikit-build/ninja-python-distributions/issues/274
-            echo "ninja==1.11.1.1"
-          ) > build_constraints.txt
-
       - name: Upload env_file
         uses: &actions-upload-artifact actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0
         with:
@@ -99,13 +87,6 @@ jobs:
           include-hidden-files: true
           overwrite: true
 
-      - name: Upload build_constraints
-        uses: *actions-upload-artifact
-        with:
-          name: build_constraints
-          path: ./build_constraints.txt
-          overwrite: true
-
       - name: Upload requirements_diff
         uses: *actions-upload-artifact
         with:
@@ -138,13 +119,6 @@ jobs:
           - os: ubuntu-latest
           - arch: aarch64
             os: ubuntu-24.04-arm
-        exclude:
-          - abi: cp314
-            arch: armv7
-          - abi: cp314
-            arch: armhf
-          - abi: cp314
-            arch: i386
     steps:
       - *checkout
 
@@ -154,12 +128,6 @@ jobs:
         with:
           name: env_file
 
-      - &download-build-constraints
-        name: Download build_constraints
-        uses: *actions-download-artifact
-        with:
-          name: build_constraints
-
       - &download-requirements-diff
         name: Download requirements_diff
         uses: *actions-download-artifact
@@ -199,7 +167,7 @@ jobs:
       - *checkout
 
       - *download-env-file
-      - *download-build-constraints
+
       - *download-requirements-diff
 
       - name: Download requirements_all_wheels
@@ -209,10 +177,6 @@ jobs:
 
       - name: Adjust build env
         run: |
-          if [ "${{ matrix.arch }}" = "i386" ]; then
-            echo "NPY_DISABLE_SVML=1" >> .env_file
-          fi
-
           # Do not pin numpy in wheels building
           sed -i "/numpy/d" homeassistant/package_constraints.txt
           # Don't build wheels for uv as uv requires a greater version of rust as currently available on alpine

CODEOWNERS

@@ -69,6 +69,8 @@ build.json @home-assistant/supervisor
 /tests/components/airly/ @bieniu
 /homeassistant/components/airnow/ @asymworks
 /tests/components/airnow/ @asymworks
+/homeassistant/components/airobot/ @mettolen
+/tests/components/airobot/ @mettolen
 /homeassistant/components/airos/ @CoMPaTech
 /tests/components/airos/ @CoMPaTech
 /homeassistant/components/airq/ @Sibgatulin @dl2080
@@ -627,6 +629,8 @@ build.json @home-assistant/supervisor
 /tests/components/guardian/ @bachya
 /homeassistant/components/habitica/ @tr4nt0r
 /tests/components/habitica/ @tr4nt0r
+/homeassistant/components/hanna/ @bestycame
+/tests/components/hanna/ @bestycame
 /homeassistant/components/hardkernel/ @home-assistant/core
 /tests/components/hardkernel/ @home-assistant/core
 /homeassistant/components/hardware/ @home-assistant/core
@@ -846,6 +850,8 @@ build.json @home-assistant/supervisor
 /tests/components/kraken/ @eifinger
 /homeassistant/components/kulersky/ @emlove
 /tests/components/kulersky/ @emlove
+/homeassistant/components/labs/ @home-assistant/core
+/tests/components/labs/ @home-assistant/core
 /homeassistant/components/lacrosse_view/ @IceBotYT
 /tests/components/lacrosse_view/ @IceBotYT
 /homeassistant/components/lamarzocco/ @zweckj

Dockerfile

@@ -21,11 +21,9 @@ ARG BUILD_ARCH
 RUN \
     case "${BUILD_ARCH}" in \
         "aarch64") go2rtc_suffix='arm64' ;; \
-        "armhf") go2rtc_suffix='armv6' ;; \
-        "armv7") go2rtc_suffix='arm' ;; \
         *) go2rtc_suffix=${BUILD_ARCH} ;; \
     esac \
-    && curl -L https://github.com/AlexxIT/go2rtc/releases/download/v1.9.11/go2rtc_linux_${go2rtc_suffix} --output /bin/go2rtc \
+    && curl -L https://github.com/AlexxIT/go2rtc/releases/download/v1.9.12/go2rtc_linux_${go2rtc_suffix} --output /bin/go2rtc \
     && chmod +x /bin/go2rtc \
     # Verify go2rtc can be executed
     && go2rtc --version

build.yaml

@@ -1,10 +1,7 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
   aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.11.0
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.11.0
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.11.0
   amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.11.0
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.11.0
 cosign:
   base_identity: https://github.com/home-assistant/docker/.*
   identity: https://github.com/home-assistant/core/.*

homeassistant/bootstrap.py

@@ -176,6 +176,8 @@ FRONTEND_INTEGRATIONS = {
 STAGE_0_INTEGRATIONS = (
     # Load logging and http deps as soon as possible
     ("logging, http deps", LOGGING_AND_HTTP_DEPS_INTEGRATIONS, None),
+    # Setup labs for preview features
+    ("labs", {"labs"}, STAGE_0_SUBSTAGE_TIMEOUT),
     # Setup frontend
     ("frontend", FRONTEND_INTEGRATIONS, None),
     # Setup recorder
@@ -212,6 +214,7 @@ DEFAULT_INTEGRATIONS = {
     "backup",
     "frontend",
     "hardware",
+    "labs",
     "logger",
     "network",
     "system_health",

homeassistant/components/actron_air/__init__.py

@@ -1,10 +1,10 @@
 """The Actron Air integration."""
 
 from actron_neo_api import (
-    ActronAirNeoACSystem,
-    ActronNeoAPI,
-    ActronNeoAPIError,
-    ActronNeoAuthError,
+    ActronAirACSystem,
+    ActronAirAPI,
+    ActronAirAPIError,
+    ActronAirAuthError,
 )
 
 from homeassistant.const import CONF_API_TOKEN, Platform
@@ -23,16 +23,16 @@ PLATFORM = [Platform.CLIMATE]
 async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
     """Set up Actron Air integration from a config entry."""
 
-    api = ActronNeoAPI(refresh_token=entry.data[CONF_API_TOKEN])
-    systems: list[ActronAirNeoACSystem] = []
+    api = ActronAirAPI(refresh_token=entry.data[CONF_API_TOKEN])
+    systems: list[ActronAirACSystem] = []
 
     try:
         systems = await api.get_ac_systems()
         await api.update_status()
-    except ActronNeoAuthError:
+    except ActronAirAuthError:
         _LOGGER.error("Authentication error while setting up Actron Air integration")
         raise
-    except ActronNeoAPIError as err:
+    except ActronAirAPIError as err:
         _LOGGER.error("API error while setting up Actron Air integration: %s", err)
         raise
 

homeassistant/components/actron_air/climate.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 
-from actron_neo_api import ActronAirNeoStatus, ActronAirNeoZone
+from actron_neo_api import ActronAirStatus, ActronAirZone
 
 from homeassistant.components.climate import (
     FAN_AUTO,
@@ -132,7 +132,7 @@ class ActronSystemClimate(BaseClimateEntity):
         return self._status.max_temp
 
     @property
-    def _status(self) -> ActronAirNeoStatus:
+    def _status(self) -> ActronAirStatus:
         """Get the current status from the coordinator."""
         return self.coordinator.data
 
@@ -194,7 +194,7 @@ class ActronZoneClimate(BaseClimateEntity):
     def __init__(
         self,
         coordinator: ActronAirSystemCoordinator,
-        zone: ActronAirNeoZone,
+        zone: ActronAirZone,
     ) -> None:
         """Initialize an Actron Air unit."""
         super().__init__(coordinator, zone.title)
@@ -221,7 +221,7 @@ class ActronZoneClimate(BaseClimateEntity):
         return self._zone.max_temp
 
     @property
-    def _zone(self) -> ActronAirNeoZone:
+    def _zone(self) -> ActronAirZone:
         """Get the current zone data from the coordinator."""
         status = self.coordinator.data
         return status.zones[self._zone_id]

homeassistant/components/actron_air/config_flow.py

@@ -3,7 +3,7 @@
 import asyncio
 from typing import Any
 
-from actron_neo_api import ActronNeoAPI, ActronNeoAuthError
+from actron_neo_api import ActronAirAPI, ActronAirAuthError
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_API_TOKEN
@@ -17,7 +17,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the config flow."""
-        self._api: ActronNeoAPI | None = None
+        self._api: ActronAirAPI | None = None
         self._device_code: str | None = None
         self._user_code: str = ""
         self._verification_uri: str = ""
@@ -30,10 +30,10 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
         """Handle the initial step."""
         if self._api is None:
             _LOGGER.debug("Initiating device authorization")
-            self._api = ActronNeoAPI()
+            self._api = ActronAirAPI()
             try:
                 device_code_response = await self._api.request_device_code()
-            except ActronNeoAuthError as err:
+            except ActronAirAuthError as err:
                 _LOGGER.error("OAuth2 flow failed: %s", err)
                 return self.async_abort(reason="oauth2_error")
 
@@ -50,7 +50,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
             try:
                 await self._api.poll_for_token(self._device_code)
                 _LOGGER.debug("Authorization successful")
-            except ActronNeoAuthError as ex:
+            except ActronAirAuthError as ex:
                 _LOGGER.exception("Error while waiting for device authorization")
                 raise CannotConnect from ex
 
@@ -89,7 +89,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
 
         try:
             user_data = await self._api.get_user_info()
-        except ActronNeoAuthError as err:
+        except ActronAirAuthError as err:
             _LOGGER.error("Error getting user info: %s", err)
             return self.async_abort(reason="oauth2_error")
 

homeassistant/components/actron_air/coordinator.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from datetime import timedelta
 
-from actron_neo_api import ActronAirNeoACSystem, ActronAirNeoStatus, ActronNeoAPI
+from actron_neo_api import ActronAirACSystem, ActronAirAPI, ActronAirStatus
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -23,7 +23,7 @@ ERROR_UNKNOWN = "unknown_error"
 class ActronAirRuntimeData:
     """Runtime data for the Actron Air integration."""
 
-    api: ActronNeoAPI
+    api: ActronAirAPI
     system_coordinators: dict[str, ActronAirSystemCoordinator]
 
 
@@ -33,15 +33,15 @@ AUTH_ERROR_THRESHOLD = 3
 SCAN_INTERVAL = timedelta(seconds=30)
 
 
-class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirNeoACSystem]):
+class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
     """System coordinator for Actron Air integration."""
 
     def __init__(
         self,
         hass: HomeAssistant,
         entry: ActronAirConfigEntry,
-        api: ActronNeoAPI,
-        system: ActronAirNeoACSystem,
+        api: ActronAirAPI,
+        system: ActronAirACSystem,
     ) -> None:
         """Initialize the coordinator."""
         super().__init__(
@@ -57,7 +57,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirNeoACSystem]):
         self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()
 
-    async def _async_update_data(self) -> ActronAirNeoStatus:
+    async def _async_update_data(self) -> ActronAirStatus:
         """Fetch updates and merge incremental changes into the full state."""
         await self.api.update_status()
         self.status = self.api.state_manager.get_status(self.serial_number)

homeassistant/components/actron_air/manifest.json

@@ -12,5 +12,5 @@
   "documentation": "https://www.home-assistant.io/integrations/actron_air",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["actron-neo-api==0.1.84"]
+  "requirements": ["actron-neo-api==0.1.87"]
 }

homeassistant/components/airobot/__init__.py

@@ -0,0 +1,29 @@
+"""The Airobot integration."""
+
+from __future__ import annotations
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
+
+PLATFORMS: list[Platform] = [Platform.CLIMATE]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:
+    """Set up Airobot from a config entry."""
+    coordinator = AirobotDataUpdateCoordinator(hass, entry)
+
+    # Fetch initial data so we have data when entities subscribe
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/airobot/climate.py

@@ -0,0 +1,151 @@
+"""Climate platform for Airobot thermostat."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pyairobotrest.const import (
+    MODE_AWAY,
+    MODE_HOME,
+    SETPOINT_TEMP_MAX,
+    SETPOINT_TEMP_MIN,
+)
+from pyairobotrest.exceptions import AirobotError
+from pyairobotrest.models import ThermostatSettings, ThermostatStatus
+
+from homeassistant.components.climate import (
+    PRESET_AWAY,
+    PRESET_BOOST,
+    PRESET_HOME,
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACAction,
+    HVACMode,
+)
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AirobotConfigEntry
+from .const import DOMAIN
+from .entity import AirobotEntity
+
+PARALLEL_UPDATES = 1
+
+_PRESET_MODE_2_MODE = {
+    PRESET_AWAY: MODE_AWAY,
+    PRESET_HOME: MODE_HOME,
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AirobotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Airobot climate platform."""
+    coordinator = entry.runtime_data
+    async_add_entities([AirobotClimate(coordinator)])
+
+
+class AirobotClimate(AirobotEntity, ClimateEntity):
+    """Representation of an Airobot thermostat."""
+
+    _attr_name = None
+    _attr_translation_key = "thermostat"
+    _attr_temperature_unit = UnitOfTemperature.CELSIUS
+    _attr_hvac_modes = [HVACMode.HEAT]
+    _attr_preset_modes = [PRESET_HOME, PRESET_AWAY, PRESET_BOOST]
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE
+    )
+    _attr_min_temp = SETPOINT_TEMP_MIN
+    _attr_max_temp = SETPOINT_TEMP_MAX
+
+    @property
+    def _status(self) -> ThermostatStatus:
+        """Get status from coordinator data."""
+        return self.coordinator.data.status
+
+    @property
+    def _settings(self) -> ThermostatSettings:
+        """Get settings from coordinator data."""
+        return self.coordinator.data.settings
+
+    @property
+    def current_temperature(self) -> float | None:
+        """Return the current temperature."""
+        return self._status.temp_air
+
+    @property
+    def target_temperature(self) -> float | None:
+        """Return the target temperature."""
+        if self._settings.is_home_mode:
+            return self._settings.setpoint_temp
+        return self._settings.setpoint_temp_away
+
+    @property
+    def hvac_mode(self) -> HVACMode:
+        """Return current HVAC mode."""
+        if self._status.is_heating:
+            return HVACMode.HEAT
+        return HVACMode.OFF
+
+    @property
+    def hvac_action(self) -> HVACAction:
+        """Return current HVAC action."""
+        if self._status.is_heating:
+            return HVACAction.HEATING
+        return HVACAction.IDLE
+
+    @property
+    def preset_mode(self) -> str | None:
+        """Return current preset mode."""
+        if self._settings.setting_flags.boost_enabled:
+            return PRESET_BOOST
+        if self._settings.is_home_mode:
+            return PRESET_HOME
+        return PRESET_AWAY
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set new target temperature."""
+        temperature = kwargs[ATTR_TEMPERATURE]
+
+        try:
+            if self._settings.is_home_mode:
+                await self.coordinator.client.set_home_temperature(float(temperature))
+            else:
+                await self.coordinator.client.set_away_temperature(float(temperature))
+        except AirobotError as err:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="set_temperature_failed",
+                translation_placeholders={"temperature": str(temperature)},
+            ) from err
+
+        await self.coordinator.async_request_refresh()
+
+    async def async_set_preset_mode(self, preset_mode: str) -> None:
+        """Set new preset mode."""
+        try:
+            if preset_mode == PRESET_BOOST:
+                # Enable boost mode
+                if not self._settings.setting_flags.boost_enabled:
+                    await self.coordinator.client.set_boost_mode(True)
+            else:
+                # Disable boost mode if it's enabled
+                if self._settings.setting_flags.boost_enabled:
+                    await self.coordinator.client.set_boost_mode(False)
+
+                # Set the mode (HOME or AWAY)
+                await self.coordinator.client.set_mode(_PRESET_MODE_2_MODE[preset_mode])
+
+        except AirobotError as err:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="set_preset_mode_failed",
+                translation_placeholders={"preset_mode": preset_mode},
+            ) from err
+
+        await self.coordinator.async_request_refresh()

homeassistant/components/airobot/config_flow.py

@@ -0,0 +1,183 @@
+"""Config flow for the Airobot integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import logging
+from typing import Any
+
+from pyairobotrest import AirobotClient
+from pyairobotrest.exceptions import (
+    AirobotAuthError,
+    AirobotConnectionError,
+    AirobotError,
+    AirobotTimeoutError,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow as BaseConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_HOST): str,
+        vol.Required(CONF_USERNAME): str,
+        vol.Required(CONF_PASSWORD): str,
+    }
+)
+
+
+@dataclass
+class DeviceInfo:
+    """Device information."""
+
+    title: str
+    device_id: str
+
+
+async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> DeviceInfo:
+    """Validate the user input allows us to connect.
+
+    Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
+    """
+    session = async_get_clientsession(hass)
+
+    client = AirobotClient(
+        host=data[CONF_HOST],
+        username=data[CONF_USERNAME],
+        password=data[CONF_PASSWORD],
+        session=session,
+    )
+
+    try:
+        # Try to fetch data to validate connection and authentication
+        status = await client.get_statuses()
+        settings = await client.get_settings()
+    except AirobotAuthError as err:
+        raise InvalidAuth from err
+    except (AirobotConnectionError, AirobotTimeoutError, AirobotError) as err:
+        raise CannotConnect from err
+
+    # Use device name or device ID as title
+    title = settings.device_name or status.device_id
+
+    return DeviceInfo(title=title, device_id=status.device_id)
+
+
+class AirobotConfigFlow(BaseConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Airobot."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._discovered_host: str | None = None
+        self._discovered_mac: str | None = None
+        self._discovered_device_id: str | None = None
+
+    async def async_step_dhcp(
+        self, discovery_info: DhcpServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle DHCP discovery."""
+        # Store the discovered IP address and MAC
+        self._discovered_host = discovery_info.ip
+        self._discovered_mac = discovery_info.macaddress
+
+        # Extract device_id from hostname (format: airobot-thermostat-t01xxxxxx)
+        hostname = discovery_info.hostname.lower()
+        device_id = hostname.replace("airobot-thermostat-", "").upper()
+        self._discovered_device_id = device_id
+        # Set unique_id to device_id for duplicate detection
+        await self.async_set_unique_id(device_id)
+        self._abort_if_unique_id_configured(updates={CONF_HOST: discovery_info.ip})
+
+        # Show the confirmation form
+        return await self.async_step_dhcp_confirm()
+
+    async def async_step_dhcp_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle DHCP discovery confirmation - ask for credentials only."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            # Combine discovered host and device_id with user-provided password
+            data = {
+                CONF_HOST: self._discovered_host,
+                CONF_USERNAME: self._discovered_device_id,
+                CONF_PASSWORD: user_input[CONF_PASSWORD],
+            }
+
+            try:
+                info = await validate_input(self.hass, data)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                # Store MAC address in config entry data
+                if self._discovered_mac:
+                    data[CONF_MAC] = self._discovered_mac
+
+                return self.async_create_entry(title=info.title, data=data)
+
+        # Only ask for password since we already have the device_id from discovery
+        return self.async_show_form(
+            step_id="dhcp_confirm",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PASSWORD): str,
+                }
+            ),
+            description_placeholders={
+                "host": self._discovered_host or "",
+                "device_id": self._discovered_device_id or "",
+            },
+            errors=errors,
+        )
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            try:
+                info = await validate_input(self.hass, user_input)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                # Use device ID as unique ID to prevent duplicates
+                await self.async_set_unique_id(info.device_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title=info.title, data=user_input)
+
+        return self.async_show_form(
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
+        )
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate we cannot connect."""
+
+
+class InvalidAuth(HomeAssistantError):
+    """Error to indicate there is invalid auth."""

homeassistant/components/airobot/const.py

@@ -0,0 +1,5 @@
+"""Constants for the Airobot integration."""
+
+from typing import Final
+
+DOMAIN: Final = "airobot"

homeassistant/components/airobot/coordinator.py

@@ -0,0 +1,59 @@
+"""Coordinator for the Airobot integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from pyairobotrest import AirobotClient
+from pyairobotrest.exceptions import AirobotAuthError, AirobotConnectionError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+from .models import AirobotData
+
+_LOGGER = logging.getLogger(__name__)
+
+# Update interval - thermostat measures air every 30 seconds
+UPDATE_INTERVAL = timedelta(seconds=30)
+
+type AirobotConfigEntry = ConfigEntry[AirobotDataUpdateCoordinator]
+
+
+class AirobotDataUpdateCoordinator(DataUpdateCoordinator[AirobotData]):
+    """Class to manage fetching Airobot data."""
+
+    config_entry: AirobotConfigEntry
+
+    def __init__(self, hass: HomeAssistant, entry: AirobotConfigEntry) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_interval=UPDATE_INTERVAL,
+            config_entry=entry,
+        )
+        session = async_get_clientsession(hass)
+
+        self.client = AirobotClient(
+            host=entry.data[CONF_HOST],
+            username=entry.data[CONF_USERNAME],
+            password=entry.data[CONF_PASSWORD],
+            session=session,
+        )
+
+    async def _async_update_data(self) -> AirobotData:
+        """Fetch data from API endpoint."""
+        try:
+            status = await self.client.get_statuses()
+            settings = await self.client.get_settings()
+        except (AirobotAuthError, AirobotConnectionError) as err:
+            raise UpdateFailed(f"Failed to communicate with device: {err}") from err
+
+        return AirobotData(status=status, settings=settings)

homeassistant/components/airobot/entity.py

@@ -0,0 +1,42 @@
+"""Base entity for Airobot integration."""
+
+from __future__ import annotations
+
+from homeassistant.const import CONF_MAC
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import AirobotDataUpdateCoordinator
+
+
+class AirobotEntity(CoordinatorEntity[AirobotDataUpdateCoordinator]):
+    """Base class for Airobot entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AirobotDataUpdateCoordinator,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        status = coordinator.data.status
+        settings = coordinator.data.settings
+
+        self._attr_unique_id = status.device_id
+
+        connections = set()
+        if (mac := coordinator.config_entry.data.get(CONF_MAC)) is not None:
+            connections.add((CONNECTION_NETWORK_MAC, mac))
+
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, status.device_id)},
+            connections=connections,
+            name=settings.device_name or status.device_id,
+            manufacturer="Airobot",
+            model="Thermostat",
+            model_id="TE1",
+            sw_version=str(status.fw_version),
+            hw_version=str(status.hw_version),
+        )

homeassistant/components/airobot/manifest.json

@@ -0,0 +1,17 @@
+{
+  "domain": "airobot",
+  "name": "Airobot",
+  "codeowners": ["@mettolen"],
+  "config_flow": true,
+  "dhcp": [
+    {
+      "hostname": "airobot-thermostat-*"
+    }
+  ],
+  "documentation": "https://www.home-assistant.io/integrations/airobot",
+  "integration_type": "device",
+  "iot_class": "local_polling",
+  "loggers": ["pyairobotrest"],
+  "quality_scale": "bronze",
+  "requirements": ["pyairobotrest==0.1.0"]
+}

homeassistant/components/airobot/models.py

@@ -0,0 +1,15 @@
+"""Models for the Airobot integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pyairobotrest.models import ThermostatSettings, ThermostatStatus
+
+
+@dataclass
+class AirobotData:
+    """Data from the Airobot coordinator."""
+
+    status: ThermostatStatus
+    settings: ThermostatSettings

homeassistant/components/airobot/quality_scale.yaml

@@ -0,0 +1,70 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: Integration does not register custom actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: Integration does not use event subscriptions.
+  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: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: done
+  discovery: done
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: todo
+  dynamic-devices:
+    status: exempt
+    comment: Single device integration, no dynamic device discovery needed.
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: done
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices:
+    status: exempt
+    comment: Single device integration, no stale device handling needed.
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

homeassistant/components/airobot/strings.json

@@ -0,0 +1,44 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "dhcp_confirm": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "The thermostat password."
+        },
+        "description": "Airobot thermostat {device_id} discovered at {host}. Enter the password to complete setup. Find the password in the thermostat settings menu under Connectivity → Mobile app."
+      },
+      "user": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "data_description": {
+          "host": "The hostname or IP address of your Airobot thermostat.",
+          "password": "The thermostat password.",
+          "username": "The thermostat Device ID (e.g., T01XXXXXX)."
+        },
+        "description": "Enter your Airobot thermostat connection details. Find the Device ID and password in the thermostat settings menu under Connectivity → Mobile app."
+      }
+    }
+  },
+  "exceptions": {
+    "set_preset_mode_failed": {
+      "message": "Failed to set preset mode to {preset_mode}."
+    },
+    "set_temperature_failed": {
+      "message": "Failed to set temperature to {temperature}."
+    }
+  }
+}

homeassistant/components/alexa_devices/config_flow.py

@@ -45,7 +45,7 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
         data[CONF_PASSWORD],
     )
 
-    return await api.login_mode_interactive(data[CONF_CODE])
+    return await api.login.login_mode_interactive(data[CONF_CODE])
 
 
 class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):

homeassistant/components/alexa_devices/coordinator.py

@@ -59,7 +59,7 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
     async def _async_update_data(self) -> dict[str, AmazonDevice]:
         """Update device data."""
         try:
-            await self.api.login_mode_stored_data()
+            await self.api.login.login_mode_stored_data()
             data = await self.api.get_devices_data()
         except CannotConnect as err:
             raise UpdateFailed(

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==8.0.1"]
+  "requirements": ["aioamazondevices==9.0.2"]
 }

homeassistant/components/analytics/__init__.py

@@ -7,7 +7,6 @@ import voluptuous as vol
 from homeassistant.components import websocket_api
 from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
 from homeassistant.core import Event, HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey
 
@@ -30,14 +29,36 @@ __all__ = [
     "async_devices_payload",
 ]
 
-CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+CONF_SNAPSHOTS_URL = "snapshots_url"
+
+CONFIG_SCHEMA = vol.Schema(
+    {
+        DOMAIN: vol.Schema(
+            {
+                vol.Optional(CONF_SNAPSHOTS_URL): vol.Any(str, None),
+            }
+        )
+    },
+    extra=vol.ALLOW_EXTRA,
+)
 
 DATA_COMPONENT: HassKey[Analytics] = HassKey(DOMAIN)
 
 
-async def async_setup(hass: HomeAssistant, _: ConfigType) -> bool:
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the analytics integration."""
-    analytics = Analytics(hass)
+    analytics_config = config.get(DOMAIN, {})
+
+    # For now we want to enable device analytics only if the url option
+    # is explicitly listed in YAML.
+    if CONF_SNAPSHOTS_URL in analytics_config:
+        disable_snapshots = False
+        snapshots_url = analytics_config[CONF_SNAPSHOTS_URL]
+    else:
+        disable_snapshots = True
+        snapshots_url = None
+
+    analytics = Analytics(hass, snapshots_url, disable_snapshots)
 
     # Load stored data
     await analytics.load()

homeassistant/components/analytics/analytics.py

@@ -59,9 +59,6 @@ from homeassistant.loader import (
 from homeassistant.setup import async_get_loaded_integrations
 
 from .const import (
-    ANALYTICS_ENDPOINT_URL,
-    ANALYTICS_ENDPOINT_URL_DEV,
-    ANALYTICS_SNAPSHOT_ENDPOINT_URL,
     ATTR_ADDON_COUNT,
     ATTR_ADDONS,
     ATTR_ARCH,
@@ -91,10 +88,14 @@ from .const import (
     ATTR_USER_COUNT,
     ATTR_UUID,
     ATTR_VERSION,
+    BASIC_ENDPOINT_URL,
+    BASIC_ENDPOINT_URL_DEV,
     DOMAIN,
     INTERVAL,
     LOGGER,
     PREFERENCE_SCHEMA,
+    SNAPSHOT_DEFAULT_URL,
+    SNAPSHOT_URL_PATH,
     SNAPSHOT_VERSION,
     STORAGE_KEY,
     STORAGE_VERSION,
@@ -236,10 +237,18 @@ class AnalyticsData:
 class Analytics:
     """Analytics helper class for the analytics integration."""
 
-    def __init__(self, hass: HomeAssistant) -> None:
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        snapshots_url: str | None = None,
+        disable_snapshots: bool = False,
+    ) -> None:
         """Initialize the Analytics class."""
-        self.hass: HomeAssistant = hass
-        self.session = async_get_clientsession(hass)
+        self._hass: HomeAssistant = hass
+        self._snapshots_url = snapshots_url
+        self._disable_snapshots = disable_snapshots
+
+        self._session = async_get_clientsession(hass)
         self._data = AnalyticsData(False, {})
         self._store = Store[dict[str, Any]](hass, STORAGE_VERSION, STORAGE_KEY)
         self._basic_scheduled: CALLBACK_TYPE | None = None
@@ -249,13 +258,15 @@ class Analytics:
     def preferences(self) -> dict:
         """Return the current active preferences."""
         preferences = self._data.preferences
-        return {
+        result = {
             ATTR_BASE: preferences.get(ATTR_BASE, False),
-            ATTR_SNAPSHOTS: preferences.get(ATTR_SNAPSHOTS, False),
             ATTR_DIAGNOSTICS: preferences.get(ATTR_DIAGNOSTICS, False),
             ATTR_USAGE: preferences.get(ATTR_USAGE, False),
             ATTR_STATISTICS: preferences.get(ATTR_STATISTICS, False),
         }
+        if not self._disable_snapshots:
+            result[ATTR_SNAPSHOTS] = preferences.get(ATTR_SNAPSHOTS, False)
+        return result
 
     @property
     def onboarded(self) -> bool:
@@ -272,13 +283,13 @@ class Analytics:
         """Return the endpoint that will receive the payload."""
         if RELEASE_CHANNEL is ReleaseChannel.DEV:
             # dev installations will contact the dev analytics environment
-            return ANALYTICS_ENDPOINT_URL_DEV
-        return ANALYTICS_ENDPOINT_URL
+            return BASIC_ENDPOINT_URL_DEV
+        return BASIC_ENDPOINT_URL
 
     @property
     def supervisor(self) -> bool:
         """Return bool if a supervisor is present."""
-        return is_hassio(self.hass)
+        return is_hassio(self._hass)
 
     async def load(self) -> None:
         """Load preferences."""
@@ -288,7 +299,7 @@ class Analytics:
 
         if (
             self.supervisor
-            and (supervisor_info := hassio.get_supervisor_info(self.hass)) is not None
+            and (supervisor_info := hassio.get_supervisor_info(self._hass)) is not None
         ):
             if not self.onboarded:
                 # User have not configured analytics, get this setting from the supervisor
@@ -315,7 +326,7 @@ class Analytics:
 
         if self.supervisor:
             await hassio.async_update_diagnostics(
-                self.hass, self.preferences.get(ATTR_DIAGNOSTICS, False)
+                self._hass, self.preferences.get(ATTR_DIAGNOSTICS, False)
             )
 
     async def send_analytics(self, _: datetime | None = None) -> None:
@@ -323,7 +334,7 @@ class Analytics:
         if not self.onboarded or not self.preferences.get(ATTR_BASE, False):
             return
 
-        hass = self.hass
+        hass = self._hass
         supervisor_info = None
         operating_system_info: dict[str, Any] = {}
 
@@ -463,7 +474,7 @@ class Analytics:
 
         try:
             async with timeout(30):
-                response = await self.session.post(self.endpoint_basic, json=payload)
+                response = await self._session.post(self.endpoint_basic, json=payload)
                 if response.status == 200:
                     LOGGER.info(
                         (
@@ -479,11 +490,9 @@ class Analytics:
                         self.endpoint_basic,
                     )
         except TimeoutError:
-            LOGGER.error("Timeout sending analytics to %s", ANALYTICS_ENDPOINT_URL)
+            LOGGER.error("Timeout sending analytics to %s", BASIC_ENDPOINT_URL)
         except aiohttp.ClientError as err:
-            LOGGER.error(
-                "Error sending analytics to %s: %r", ANALYTICS_ENDPOINT_URL, err
-            )
+            LOGGER.error("Error sending analytics to %s: %r", BASIC_ENDPOINT_URL, err)
 
     @callback
     def _async_should_report_integration(
@@ -507,7 +516,7 @@ class Analytics:
         if not integration.config_flow:
             return False
 
-        entries = self.hass.config_entries.async_entries(integration.domain)
+        entries = self._hass.config_entries.async_entries(integration.domain)
 
         # Filter out ignored and disabled entries
         return any(
@@ -521,7 +530,7 @@ class Analytics:
         if not self.onboarded or not self.preferences.get(ATTR_SNAPSHOTS, False):
             return
 
-        payload = await _async_snapshot_payload(self.hass)
+        payload = await _async_snapshot_payload(self._hass)
 
         headers = {
             "Content-Type": "application/json",
@@ -532,11 +541,16 @@ class Analytics:
                 self._data.submission_identifier
             )
 
+        url = (
+            self._snapshots_url
+            if self._snapshots_url is not None
+            else SNAPSHOT_DEFAULT_URL
+        )
+        url += SNAPSHOT_URL_PATH
+
         try:
             async with timeout(30):
-                response = await self.session.post(
-                    ANALYTICS_SNAPSHOT_ENDPOINT_URL, json=payload, headers=headers
-                )
+                response = await self._session.post(url, json=payload, headers=headers)
 
                 if response.status == 200:  # OK
                     response_data = await response.json()
@@ -562,7 +576,7 @@ class Analytics:
                         # Clear the invalid identifier and retry on next cycle
                         LOGGER.warning(
                             "Invalid submission identifier to %s, clearing: %s",
-                            ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                            url,
                             error_message,
                         )
                         self._data.submission_identifier = None
@@ -571,7 +585,7 @@ class Analytics:
                         LOGGER.warning(
                             "Malformed snapshot analytics submission (%s) to %s: %s",
                             error_kind,
-                            ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                            url,
                             error_message,
                         )
 
@@ -579,7 +593,7 @@ class Analytics:
                     response_text = await response.text()
                     LOGGER.warning(
                         "Snapshot analytics service %s unavailable: %s",
-                        ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                        url,
                         response_text,
                     )
 
@@ -587,18 +601,18 @@ class Analytics:
                     LOGGER.warning(
                         "Unexpected status code %s when submitting snapshot analytics to %s",
                         response.status,
-                        ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                        url,
                     )
 
         except TimeoutError:
             LOGGER.error(
                 "Timeout sending snapshot analytics to %s",
-                ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                url,
             )
         except aiohttp.ClientError as err:
             LOGGER.error(
                 "Error sending snapshot analytics to %s: %r",
-                ANALYTICS_SNAPSHOT_ENDPOINT_URL,
+                url,
                 err,
             )
 
@@ -622,7 +636,7 @@ class Analytics:
         elif self._basic_scheduled is None:
             # Wait 15 min after started for basic analytics
             self._basic_scheduled = async_call_later(
-                self.hass,
+                self._hass,
                 900,
                 HassJob(
                     self._async_schedule_basic,
@@ -631,10 +645,7 @@ class Analytics:
                 ),
             )
 
-        if not self.preferences.get(ATTR_SNAPSHOTS, False) or RELEASE_CHANNEL not in (
-            ReleaseChannel.DEV,
-            ReleaseChannel.NIGHTLY,
-        ):
+        if not self.preferences.get(ATTR_SNAPSHOTS, False) or self._disable_snapshots:
             LOGGER.debug("Snapshot analytics not scheduled")
             if self._snapshot_scheduled:
                 self._snapshot_scheduled()
@@ -642,9 +653,11 @@ class Analytics:
         elif self._snapshot_scheduled is None:
             snapshot_submission_time = self._data.snapshot_submission_time
 
+            interval_seconds = INTERVAL.total_seconds()
+
             if snapshot_submission_time is None:
                 # Randomize the submission time within the 24 hours
-                snapshot_submission_time = random.uniform(0, 86400)
+                snapshot_submission_time = random.uniform(0, interval_seconds)
                 self._data.snapshot_submission_time = snapshot_submission_time
                 await self._save()
                 LOGGER.debug(
@@ -654,10 +667,10 @@ class Analytics:
 
             # Calculate delay until next submission
             current_time = time.time()
-            delay = (snapshot_submission_time - current_time) % 86400
+            delay = (snapshot_submission_time - current_time) % interval_seconds
 
             self._snapshot_scheduled = async_call_later(
-                self.hass,
+                self._hass,
                 delay,
                 HassJob(
                     self._async_schedule_snapshots,
@@ -672,7 +685,7 @@ class Analytics:
 
         # Send basic analytics every day
         self._basic_scheduled = async_track_time_interval(
-            self.hass,
+            self._hass,
             self.send_analytics,
             INTERVAL,
             name="basic analytics daily",
@@ -685,7 +698,7 @@ class Analytics:
 
         # Send snapshot analytics every day
         self._snapshot_scheduled = async_track_time_interval(
-            self.hass,
+            self._hass,
             self.send_snapshot,
             INTERVAL,
             name="snapshot analytics daily",

homeassistant/components/analytics/const.py

@@ -5,15 +5,17 @@ import logging
 
 import voluptuous as vol
 
-ANALYTICS_ENDPOINT_URL = "https://analytics-api.home-assistant.io/v1"
-ANALYTICS_ENDPOINT_URL_DEV = "https://analytics-api-dev.home-assistant.io/v1"
-SNAPSHOT_VERSION = "1"
-ANALYTICS_SNAPSHOT_ENDPOINT_URL = f"https://device-database.eco-dev-aws.openhomefoundation.com/api/v1/snapshot/{SNAPSHOT_VERSION}"
 DOMAIN = "analytics"
 INTERVAL = timedelta(days=1)
 STORAGE_KEY = "core.analytics"
 STORAGE_VERSION = 1
 
+BASIC_ENDPOINT_URL = "https://analytics-api.home-assistant.io/v1"
+BASIC_ENDPOINT_URL_DEV = "https://analytics-api-dev.home-assistant.io/v1"
+
+SNAPSHOT_VERSION = 1
+SNAPSHOT_DEFAULT_URL = "https://device-database.eco-dev-aws.openhomefoundation.com"
+SNAPSHOT_URL_PATH = f"/api/v1/snapshot/{SNAPSHOT_VERSION}"
 
 LOGGER: logging.Logger = logging.getLogger(__package__)
 

homeassistant/components/awair/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/awair",
   "iot_class": "local_polling",
   "loggers": ["python_awair"],
-  "requirements": ["python-awair==0.2.4"],
+  "requirements": ["python-awair==0.2.5"],
   "zeroconf": [
     {
       "name": "awair*",

homeassistant/components/brother/entity.py

@@ -24,7 +24,7 @@ class BrotherPrinterEntity(CoordinatorEntity[BrotherDataUpdateCoordinator]):
             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/manifest.json

@@ -8,7 +8,8 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["brother", "pyasn1", "pysmi", "pysnmp"],
-  "requirements": ["brother==5.1.1"],
+  "quality_scale": "platinum",
+  "requirements": ["brother==6.0.0"],
   "zeroconf": [
     {
       "name": "brother*",

homeassistant/components/brother/quality_scale.yaml

@@ -0,0 +1,78 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: The integration does not register services.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: The integration does not register services.
+  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: The integration does not register services.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options to configure.
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow:
+    status: exempt
+    comment: SNMP doesn't return error identifying an authentication problem, to change the SNMP community (simple password) the user should use reconfigure flow.
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: done
+  discovery-update-info: done
+  discovery: done
+  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:
+    status: exempt
+    comment: This integration has a fixed single device.
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: done
+  entity-translations: done
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow: done
+  repair-issues:
+    status: exempt
+    comment: This integration doesn't have any cases where raising an issue is needed.
+  stale-devices:
+    status: exempt
+    comment: This integration has a fixed single device.
+
+  # Platinum
+  async-dependency: done
+  inject-websession:
+    status: exempt
+    comment: The integration does not connect via HTTP instead it uses a shared SNMP engine.
+  strict-typing: done

homeassistant/components/brother/sensor.py

@@ -17,7 +17,7 @@ from homeassistant.components.sensor import (
     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 @@ class BrotherPrinterSensor(BrotherPrinterEntity, SensorEntity):
         """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/cloud/__init__.py

@@ -7,7 +7,7 @@ from collections.abc import Awaitable, Callable
 from datetime import datetime, timedelta
 from enum import Enum
 import logging
-from typing import cast
+from typing import Any, cast
 
 from hass_nabucasa import Cloud
 import voluptuous as vol
@@ -86,6 +86,10 @@ SIGNAL_CLOUD_CONNECTION_STATE: SignalType[CloudConnectionState] = SignalType(
     "CLOUD_CONNECTION_STATE"
 )
 
+_SIGNAL_CLOUDHOOKS_UPDATED: SignalType[dict[str, Any]] = SignalType(
+    "CLOUDHOOKS_UPDATED"
+)
+
 STARTUP_REPAIR_DELAY = 1  # 1 hour
 
 ALEXA_ENTITY_SCHEMA = vol.Schema(
@@ -242,6 +246,24 @@ async def async_delete_cloudhook(hass: HomeAssistant, webhook_id: str) -> None:
     await hass.data[DATA_CLOUD].cloudhooks.async_delete(webhook_id)
 
 
+@callback
+def async_listen_cloudhook_change(
+    hass: HomeAssistant,
+    webhook_id: str,
+    on_change: Callable[[dict[str, Any] | None], None],
+) -> Callable[[], None]:
+    """Listen for cloudhook changes for the given webhook and notify when modified or deleted."""
+
+    @callback
+    def _handle_cloudhooks_updated(cloudhooks: dict[str, Any]) -> None:
+        """Handle cloudhooks updated signal."""
+        on_change(cloudhooks.get(webhook_id))
+
+    return async_dispatcher_connect(
+        hass, _SIGNAL_CLOUDHOOKS_UPDATED, _handle_cloudhooks_updated
+    )
+
+
 @bind_hass
 @callback
 def async_remote_ui_url(hass: HomeAssistant) -> str:
@@ -289,7 +311,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)
 
-    _remote_handle_prefs_updated(cloud)
+    _handle_prefs_updated(hass, cloud)
     _setup_services(hass, prefs)
 
     async def async_startup_repairs(_: datetime) -> None:
@@ -373,26 +395,32 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
 
 @callback
-def _remote_handle_prefs_updated(cloud: Cloud[CloudClient]) -> None:
-    """Handle remote preferences updated."""
-    cur_pref = cloud.client.prefs.remote_enabled
+def _handle_prefs_updated(hass: HomeAssistant, cloud: Cloud[CloudClient]) -> None:
+    """Register handler for cloud preferences updates."""
+    cur_remote_enabled = cloud.client.prefs.remote_enabled
+    cur_cloudhooks = cloud.client.prefs.cloudhooks
     lock = asyncio.Lock()
 
-    # Sync remote connection with prefs
-    async def remote_prefs_updated(prefs: CloudPreferences) -> None:
-        """Update remote status."""
-        nonlocal cur_pref
+    async def on_prefs_updated(prefs: CloudPreferences) -> None:
+        """Handle cloud preferences updates."""
+        nonlocal cur_remote_enabled
+        nonlocal cur_cloudhooks
 
+        # Lock protects cur_ state variables from concurrent updates
         async with lock:
-            if prefs.remote_enabled == cur_pref:
+            if cur_cloudhooks != prefs.cloudhooks:
+                cur_cloudhooks = prefs.cloudhooks
+                async_dispatcher_send(hass, _SIGNAL_CLOUDHOOKS_UPDATED, cur_cloudhooks)
+
+            if prefs.remote_enabled == cur_remote_enabled:
                 return
 
-            if cur_pref := prefs.remote_enabled:
+            if cur_remote_enabled := prefs.remote_enabled:
                 await cloud.remote.connect()
             else:
                 await cloud.remote.disconnect()
 
-    cloud.client.prefs.async_listen_updates(remote_prefs_updated)
+    cloud.client.prefs.async_listen_updates(on_prefs_updated)
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

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/decora_wifi/light.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from datetime import timedelta
 import logging
 from typing import Any
 
@@ -25,6 +26,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
+from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -167,6 +169,7 @@ class DecoraWifiLight(LightEntity):
         except ValueError:
             _LOGGER.error("Failed to turn off myLeviton switch")
 
+    @Throttle(timedelta(seconds=30))
     def update(self) -> None:
         """Fetch new state data for this switch."""
         try:

homeassistant/components/derivative/icons.json

@@ -5,5 +5,10 @@
         "default": "mdi:chart-line"
       }
     }
+  },
+  "services": {
+    "reload": {
+      "service": "mdi:reload"
+    }
   }
 }

homeassistant/components/derivative/sensor.py

@@ -20,8 +20,10 @@ from homeassistant.const import (
     ATTR_UNIT_OF_MEASUREMENT,
     CONF_NAME,
     CONF_SOURCE,
+    CONF_UNIQUE_ID,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
+    Platform,
     UnitOfTime,
 )
 from homeassistant.core import (
@@ -44,6 +46,7 @@ from homeassistant.helpers.event import (
     async_track_state_change_event,
     async_track_state_report_event,
 )
+from homeassistant.helpers.reload import async_setup_reload_service
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import (
@@ -53,6 +56,7 @@ from .const import (
     CONF_UNIT,
     CONF_UNIT_PREFIX,
     CONF_UNIT_TIME,
+    DOMAIN,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -85,6 +89,7 @@ DEFAULT_TIME_WINDOW = 0
 PLATFORM_SCHEMA = SENSOR_PLATFORM_SCHEMA.extend(
     {
         vol.Optional(CONF_NAME): cv.string,
+        vol.Optional(CONF_UNIQUE_ID): cv.string,
         vol.Required(CONF_SOURCE): cv.entity_id,
         vol.Optional(CONF_ROUND_DIGITS, default=DEFAULT_ROUND): vol.Coerce(int),
         vol.Optional(CONF_UNIT_PREFIX, default=None): vol.In(UNIT_PREFIXES),
@@ -145,6 +150,8 @@ async def async_setup_platform(
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
     """Set up the derivative sensor."""
+    await async_setup_reload_service(hass, DOMAIN, [Platform.SENSOR])
+
     derivative = DerivativeSensor(
         hass,
         name=config.get(CONF_NAME),
@@ -154,7 +161,7 @@ async def async_setup_platform(
         unit_of_measurement=config.get(CONF_UNIT),
         unit_prefix=config[CONF_UNIT_PREFIX],
         unit_time=config[CONF_UNIT_TIME],
-        unique_id=None,
+        unique_id=config.get(CONF_UNIQUE_ID),
         max_sub_interval=config.get(CONF_MAX_SUB_INTERVAL),
     )
 
@@ -286,14 +293,14 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
         )
         self.async_write_ha_state()
 
-    async def async_added_to_hass(self) -> None:
-        """Handle entity which will be added."""
-        await super().async_added_to_hass()
+    async def _handle_restore(self) -> None:
         restored_data = await self.async_get_last_sensor_data()
         if restored_data:
-            self._attr_native_unit_of_measurement = (
-                restored_data.native_unit_of_measurement
-            )
+            if self._attr_native_unit_of_measurement is None:
+                # Only restore the unit if it's not assigned from YAML
+                self._attr_native_unit_of_measurement = (
+                    restored_data.native_unit_of_measurement
+                )
             try:
                 self._attr_native_value = round(
                     Decimal(restored_data.native_value),  # type: ignore[arg-type]
@@ -302,6 +309,11 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
             except (InvalidOperation, TypeError):
                 self._attr_native_value = None
 
+    async def async_added_to_hass(self) -> None:
+        """Handle entity which will be added."""
+        await super().async_added_to_hass()
+        await self._handle_restore()
+
         source_state = self.hass.states.get(self._sensor_source_id)
         self._derive_and_set_attributes_from_state(source_state)
 

homeassistant/components/derivative/services.yaml

@@ -0,0 +1 @@
+reload:

homeassistant/components/derivative/strings.json

@@ -58,5 +58,11 @@
       }
     }
   },
+  "services": {
+    "reload": {
+      "description": "Reloads derivative sensors from the YAML-configuration.",
+      "name": "[%key:common::action::reload%]"
+    }
+  },
   "title": "Derivative sensor"
 }

homeassistant/components/dominos/__init__.py

@@ -1,259 +0,0 @@
-"""Support for Dominos Pizza ordering."""
-
-from datetime import timedelta
-import logging
-
-from pizzapi import Address, Customer, Order
-import voluptuous as vol
-
-from homeassistant.components import http
-from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.entity import Entity
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.util import Throttle
-
-_LOGGER = logging.getLogger(__name__)
-
-# The domain of your component. Should be equal to the name of your component.
-DOMAIN = "dominos"
-ENTITY_ID_FORMAT = DOMAIN + ".{}"
-
-ATTR_COUNTRY = "country_code"
-ATTR_FIRST_NAME = "first_name"
-ATTR_LAST_NAME = "last_name"
-ATTR_EMAIL = "email"
-ATTR_PHONE = "phone"
-ATTR_ADDRESS = "address"
-ATTR_ORDERS = "orders"
-ATTR_SHOW_MENU = "show_menu"
-ATTR_ORDER_ENTITY = "order_entity_id"
-ATTR_ORDER_NAME = "name"
-ATTR_ORDER_CODES = "codes"
-
-MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=10)
-MIN_TIME_BETWEEN_STORE_UPDATES = timedelta(minutes=3330)
-
-_ORDERS_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_ORDER_NAME): cv.string,
-        vol.Required(ATTR_ORDER_CODES): vol.All(cv.ensure_list, [cv.string]),
-    }
-)
-
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.Schema(
-            {
-                vol.Required(ATTR_COUNTRY): cv.string,
-                vol.Required(ATTR_FIRST_NAME): cv.string,
-                vol.Required(ATTR_LAST_NAME): cv.string,
-                vol.Required(ATTR_EMAIL): cv.string,
-                vol.Required(ATTR_PHONE): cv.string,
-                vol.Required(ATTR_ADDRESS): cv.string,
-                vol.Optional(ATTR_SHOW_MENU): cv.boolean,
-                vol.Optional(ATTR_ORDERS, default=[]): vol.All(
-                    cv.ensure_list, [_ORDERS_SCHEMA]
-                ),
-            }
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
-
-
-def setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up is called when Home Assistant is loading our component."""
-    dominos = Dominos(hass, config)
-
-    component = EntityComponent[DominosOrder](_LOGGER, DOMAIN, hass)
-    hass.data[DOMAIN] = {}
-    entities: list[DominosOrder] = []
-    conf = config[DOMAIN]
-
-    hass.services.register(
-        DOMAIN,
-        "order",
-        dominos.handle_order,
-        vol.Schema(
-            {
-                vol.Required(ATTR_ORDER_ENTITY): cv.entity_ids,
-            }
-        ),
-    )
-
-    if conf.get(ATTR_SHOW_MENU):
-        hass.http.register_view(DominosProductListView(dominos))
-
-    for order_info in conf.get(ATTR_ORDERS):
-        order = DominosOrder(order_info, dominos)
-        entities.append(order)
-
-    component.add_entities(entities)
-
-    # Return boolean to indicate that initialization was successfully.
-    return True
-
-
-class Dominos:
-    """Main Dominos service."""
-
-    def __init__(self, hass, config):
-        """Set up main service."""
-        conf = config[DOMAIN]
-
-        self.hass = hass
-        self.customer = Customer(
-            conf.get(ATTR_FIRST_NAME),
-            conf.get(ATTR_LAST_NAME),
-            conf.get(ATTR_EMAIL),
-            conf.get(ATTR_PHONE),
-            conf.get(ATTR_ADDRESS),
-        )
-        self.address = Address(
-            *self.customer.address.split(","), country=conf.get(ATTR_COUNTRY)
-        )
-        self.country = conf.get(ATTR_COUNTRY)
-        try:
-            self.closest_store = self.address.closest_store()
-        except Exception:  # noqa: BLE001
-            self.closest_store = None
-
-    def handle_order(self, call: ServiceCall) -> None:
-        """Handle ordering pizza."""
-        entity_ids = call.data[ATTR_ORDER_ENTITY]
-
-        target_orders = [
-            order
-            for order in self.hass.data[DOMAIN]["entities"]
-            if order.entity_id in entity_ids
-        ]
-
-        for order in target_orders:
-            order.place()
-
-    @Throttle(MIN_TIME_BETWEEN_STORE_UPDATES)
-    def update_closest_store(self):
-        """Update the shared closest store (if open)."""
-        try:
-            self.closest_store = self.address.closest_store()
-        except Exception:  # noqa: BLE001
-            self.closest_store = None
-            return False
-        return True
-
-    def get_menu(self):
-        """Return the products from the closest stores menu."""
-        self.update_closest_store()
-        if self.closest_store is None:
-            _LOGGER.warning("Cannot get menu. Store may be closed")
-            return []
-        menu = self.closest_store.get_menu()
-        product_entries = []
-
-        for product in menu.products:
-            item = {}
-            if isinstance(product.menu_data["Variants"], list):
-                variants = ", ".join(product.menu_data["Variants"])
-            else:
-                variants = product.menu_data["Variants"]
-            item["name"] = product.name
-            item["variants"] = variants
-            product_entries.append(item)
-
-        return product_entries
-
-
-class DominosProductListView(http.HomeAssistantView):
-    """View to retrieve product list content."""
-
-    url = "/api/dominos"
-    name = "api:dominos"
-
-    def __init__(self, dominos):
-        """Initialize suite view."""
-        self.dominos = dominos
-
-    @callback
-    def get(self, request):
-        """Retrieve if API is running."""
-        return self.json(self.dominos.get_menu())
-
-
-class DominosOrder(Entity):
-    """Represents a Dominos order entity."""
-
-    def __init__(self, order_info, dominos):
-        """Set up the entity."""
-        self._name = order_info["name"]
-        self._product_codes = order_info["codes"]
-        self._orderable = False
-        self.dominos = dominos
-
-    @property
-    def name(self):
-        """Return the orders name."""
-        return self._name
-
-    @property
-    def product_codes(self):
-        """Return the orders product codes."""
-        return self._product_codes
-
-    @property
-    def orderable(self):
-        """Return the true if orderable."""
-        return self._orderable
-
-    @property
-    def state(self):
-        """Return the state either closed, orderable or unorderable."""
-        if self.dominos.closest_store is None:
-            return "closed"
-        return "orderable" if self._orderable else "unorderable"
-
-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Update the order state and refreshes the store."""
-        try:
-            self.dominos.update_closest_store()
-        except Exception:  # noqa: BLE001
-            self._orderable = False
-            return
-
-        try:
-            order = self.order()
-            order.pay_with()
-            self._orderable = True
-        except Exception:  # noqa: BLE001
-            self._orderable = False
-
-    def order(self):
-        """Create the order object."""
-        if self.dominos.closest_store is None:
-            raise HomeAssistantError("No store available")
-
-        order = Order(
-            self.dominos.closest_store,
-            self.dominos.customer,
-            self.dominos.address,
-            self.dominos.country,
-        )
-
-        for code in self._product_codes:
-            order.add_item(code)
-
-        return order
-
-    def place(self):
-        """Place the order."""
-        try:
-            order = self.order()
-            order.place()
-        except Exception:  # noqa: BLE001
-            self._orderable = False
-            _LOGGER.warning(
-                "Attempted to order Dominos - Order invalid or store closed"
-            )

homeassistant/components/dominos/icons.json

@@ -1,7 +0,0 @@
-{
-  "services": {
-    "order": {
-      "service": "mdi:pizza"
-    }
-  }
-}

homeassistant/components/dominos/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "dominos",
-  "name": "Dominos Pizza",
-  "codeowners": [],
-  "dependencies": ["http"],
-  "documentation": "https://www.home-assistant.io/integrations/dominos",
-  "iot_class": "cloud_polling",
-  "loggers": ["pizzapi"],
-  "quality_scale": "legacy",
-  "requirements": ["pizzapi==0.0.6"]
-}

homeassistant/components/dominos/services.yaml

@@ -1,6 +0,0 @@
-order:
-  fields:
-    order_entity_id:
-      example: dominos.medium_pan
-      selector:
-        text:

homeassistant/components/dominos/strings.json

@@ -1,14 +0,0 @@
-{
-  "services": {
-    "order": {
-      "description": "Places a set of orders with Domino's Pizza.",
-      "fields": {
-        "order_entity_id": {
-          "description": "The ID (as specified in the configuration) of an order to place. If provided as an array, all the identified orders will be placed.",
-          "name": "Order entity"
-        }
-      },
-      "name": "Order"
-    }
-  }
-}

homeassistant/components/emoncms/sensor.py

@@ -29,9 +29,9 @@ from homeassistant.const import (
     UnitOfVolumeFlowRate,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import template
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.util import dt as dt_util
 
 from .config_flow import sensor_name
 from .const import CONF_ONLY_INCLUDE_FEEDID, FEED_ID, FEED_NAME, FEED_TAG
@@ -267,7 +267,9 @@ class EmonCmsSensor(CoordinatorEntity[EmoncmsCoordinator], SensorEntity):
             self._attr_extra_state_attributes[ATTR_USERID] = elem["userid"]
             self._attr_extra_state_attributes[ATTR_LASTUPDATETIME] = elem["time"]
             self._attr_extra_state_attributes[ATTR_LASTUPDATETIMESTR] = (
-                template.timestamp_local(float(elem["time"]))
+                dt_util.as_local(
+                    dt_util.utc_from_timestamp(float(elem["time"]))
+                ).isoformat()
             )
 
         self._attr_native_value = None

homeassistant/components/frontend/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251105.0"]
+  "requirements": ["home-assistant-frontend==20251105.1"]
 }

homeassistant/components/frontend/storage.py

@@ -11,11 +11,14 @@ import voluptuous as vol
 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:
@@ -23,6 +26,9 @@ async def async_setup_frontend_storage(hass: HomeAssistant) -> None:
     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 @@ class _UserStore(Store[dict[str, Any]]):
         )
 
 
+@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 @@ def with_user_store(
     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 @@ async def websocket_subscribe_user_data(
     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/generic/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/generic",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["av==13.1.0", "Pillow==12.0.0"]
+  "requirements": ["av==16.0.1", "Pillow==12.0.0"]
 }

homeassistant/components/go2rtc/__init__.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+from dataclasses import dataclass
 import logging
+from secrets import token_hex
 import shutil
 
-from aiohttp import ClientSession
+from aiohttp import BasicAuth, ClientSession, UnixConnector
 from aiohttp.client_exceptions import ClientConnectionError, ServerConnectionError
 from awesomeversion import AwesomeVersion
 from go2rtc_client import Go2RtcRestClient
@@ -35,7 +37,12 @@ from homeassistant.components.camera import (
 from homeassistant.components.default_config import DOMAIN as DEFAULT_CONFIG_DOMAIN
 from homeassistant.components.stream import Orientation
 from homeassistant.config_entries import SOURCE_SYSTEM, ConfigEntry
-from homeassistant.const import CONF_URL, EVENT_HOMEASSISTANT_STOP
+from homeassistant.const import (
+    CONF_PASSWORD,
+    CONF_URL,
+    CONF_USERNAME,
+    EVENT_HOMEASSISTANT_STOP,
+)
 from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryNotReady, HomeAssistantError
 from homeassistant.helpers import (
@@ -43,7 +50,10 @@ from homeassistant.helpers import (
     discovery_flow,
     issue_registry as ir,
 )
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.aiohttp_client import (
+    async_create_clientsession,
+    async_get_clientsession,
+)
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.package import is_docker_env
@@ -52,6 +62,7 @@ from .const import (
     CONF_DEBUG_UI,
     DEBUG_UI_URL_MESSAGE,
     DOMAIN,
+    HA_MANAGED_UNIX_SOCKET,
     HA_MANAGED_URL,
     RECOMMENDED_VERSION,
 )
@@ -60,49 +71,49 @@ from .server import Server
 _LOGGER = logging.getLogger(__name__)
 
 _FFMPEG = "ffmpeg"
-_SUPPORTED_STREAMS = frozenset(
-    (
-        "bubble",
-        "dvrip",
-        "expr",
-        _FFMPEG,
-        "gopro",
-        "homekit",
-        "http",
-        "https",
-        "httpx",
-        "isapi",
-        "ivideon",
-        "kasa",
-        "nest",
-        "onvif",
-        "roborock",
-        "rtmp",
-        "rtmps",
-        "rtmpx",
-        "rtsp",
-        "rtsps",
-        "rtspx",
-        "tapo",
-        "tcp",
-        "webrtc",
-        "webtorrent",
-    )
-)
+_AUTH = "auth"
+
+
+def _validate_auth(config: dict) -> dict:
+    """Validate that username and password are only set when a URL is configured or when debug UI is enabled."""
+    auth_exists = CONF_USERNAME in config
+    debug_ui_enabled = config.get(CONF_DEBUG_UI, False)
+
+    if debug_ui_enabled and not auth_exists:
+        raise vol.Invalid("Username and password must be set when debug_ui is true")
+
+    if auth_exists and CONF_URL not in config and not debug_ui_enabled:
+        raise vol.Invalid(
+            "Username and password can only be set when a URL is configured or debug_ui is true"
+        )
+
+    return config
+
 
 CONFIG_SCHEMA = vol.Schema(
     {
-        DOMAIN: vol.Schema(
-            {
-                vol.Exclusive(CONF_URL, DOMAIN, DEBUG_UI_URL_MESSAGE): cv.url,
-                vol.Exclusive(CONF_DEBUG_UI, DOMAIN, DEBUG_UI_URL_MESSAGE): cv.boolean,
-            }
+        DOMAIN: vol.All(
+            vol.Schema(
+                {
+                    vol.Exclusive(CONF_URL, DOMAIN, DEBUG_UI_URL_MESSAGE): cv.url,
+                    vol.Exclusive(
+                        CONF_DEBUG_UI, DOMAIN, DEBUG_UI_URL_MESSAGE
+                    ): cv.boolean,
+                    vol.Inclusive(CONF_USERNAME, _AUTH): vol.All(
+                        cv.string, vol.Length(min=1)
+                    ),
+                    vol.Inclusive(CONF_PASSWORD, _AUTH): vol.All(
+                        cv.string, vol.Length(min=1)
+                    ),
+                }
+            ),
+            _validate_auth,
         )
     },
     extra=vol.ALLOW_EXTRA,
 )
 
-_DATA_GO2RTC: HassKey[str] = HassKey(DOMAIN)
+_DATA_GO2RTC: HassKey[Go2RtcConfig] = HassKey(DOMAIN)
 _RETRYABLE_ERRORS = (ClientConnectionError, ServerConnectionError)
 type Go2RtcConfigEntry = ConfigEntry[WebRTCProvider]
 
@@ -110,12 +121,19 @@ type Go2RtcConfigEntry = ConfigEntry[WebRTCProvider]
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up WebRTC."""
     url: str | None = None
+    username: str | None = None
+    password: str | None = None
+
     if DOMAIN not in config and DEFAULT_CONFIG_DOMAIN not in config:
         await _remove_go2rtc_entries(hass)
         return True
 
+    domain_config = config.get(DOMAIN, {})
+    username = domain_config.get(CONF_USERNAME)
+    password = domain_config.get(CONF_PASSWORD)
+
     if not (configured_by_user := DOMAIN in config) or not (
-        url := config[DOMAIN].get(CONF_URL)
+        url := domain_config.get(CONF_URL)
     ):
         if not is_docker_env():
             if not configured_by_user:
@@ -128,9 +146,26 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             _LOGGER.error("Could not find go2rtc docker binary")
             return False
 
+        # Generate random credentials when not provided to secure the server
+        if not username or not password:
+            username = token_hex()
+            password = token_hex()
+            _LOGGER.debug("Generated random credentials for go2rtc server")
+
+        auth = BasicAuth(username, password)
         # HA will manage the binary
+        # Manually created session (not using the helper) needs to be closed manually
+        # See on_stop listener below
+        session = ClientSession(
+            connector=UnixConnector(path=HA_MANAGED_UNIX_SOCKET), auth=auth
+        )
         server = Server(
-            hass, binary, enable_ui=config.get(DOMAIN, {}).get(CONF_DEBUG_UI, False)
+            hass,
+            binary,
+            session,
+            enable_ui=domain_config.get(CONF_DEBUG_UI, False),
+            username=username,
+            password=password,
         )
         try:
             await server.start()
@@ -140,12 +175,19 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
         async def on_stop(event: Event) -> None:
             await server.stop()
+            await session.close()
 
         hass.bus.async_listen(EVENT_HOMEASSISTANT_STOP, on_stop)
 
         url = HA_MANAGED_URL
+    elif username and password:
+        # Create session with BasicAuth if credentials are provided
+        auth = BasicAuth(username, password)
+        session = async_create_clientsession(hass, auth=auth)
+    else:
+        session = async_get_clientsession(hass)
 
-    hass.data[_DATA_GO2RTC] = url
+    hass.data[_DATA_GO2RTC] = Go2RtcConfig(url, session)
     discovery_flow.async_create_flow(
         hass, DOMAIN, context={"source": SOURCE_SYSTEM}, data={}
     )
@@ -161,8 +203,9 @@ async def _remove_go2rtc_entries(hass: HomeAssistant) -> None:
 async def async_setup_entry(hass: HomeAssistant, entry: Go2RtcConfigEntry) -> bool:
     """Set up go2rtc from a config entry."""
 
-    url = hass.data[_DATA_GO2RTC]
-    session = async_get_clientsession(hass)
+    config = hass.data[_DATA_GO2RTC]
+    url = config.url
+    session = config.session
     client = Go2RtcRestClient(session, url)
     # Validate the server URL
     try:
@@ -197,6 +240,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: Go2RtcConfigEntry) -> bo
         return False
 
     provider = entry.runtime_data = WebRTCProvider(hass, url, session, client)
+    await provider.initialize()
     entry.async_on_unload(async_register_webrtc_provider(hass, provider))
     return True
 
@@ -228,16 +272,21 @@ class WebRTCProvider(CameraWebRTCProvider):
         self._session = session
         self._rest_client = rest_client
         self._sessions: dict[str, Go2RtcWsClient] = {}
+        self._supported_schemes: set[str] = set()
 
     @property
     def domain(self) -> str:
         """Return the integration domain of the provider."""
         return DOMAIN
 
+    async def initialize(self) -> None:
+        """Initialize the provider."""
+        self._supported_schemes = await self._rest_client.schemes.list()
+
     @callback
     def async_is_supported(self, stream_source: str) -> bool:
         """Return if this provider is supports the Camera as source."""
-        return stream_source.partition(":")[0] in _SUPPORTED_STREAMS
+        return stream_source.partition(":")[0] in self._supported_schemes
 
     async def async_handle_async_webrtc_offer(
         self,
@@ -365,3 +414,11 @@ class WebRTCProvider(CameraWebRTCProvider):
         for ws_client in self._sessions.values():
             await ws_client.close()
         self._sessions.clear()
+
+
+@dataclass
+class Go2RtcConfig:
+    """Go2rtc configuration."""
+
+    url: str
+    session: ClientSession

homeassistant/components/go2rtc/const.py

@@ -6,4 +6,5 @@ CONF_DEBUG_UI = "debug_ui"
 DEBUG_UI_URL_MESSAGE = "Url and debug_ui cannot be set at the same time."
 HA_MANAGED_API_PORT = 11984
 HA_MANAGED_URL = f"http://localhost:{HA_MANAGED_API_PORT}/"
-RECOMMENDED_VERSION = "1.9.11"
+HA_MANAGED_UNIX_SOCKET = "/run/go2rtc.sock"
+RECOMMENDED_VERSION = "1.9.12"

homeassistant/components/go2rtc/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "system",
   "iot_class": "local_polling",
   "quality_scale": "internal",
-  "requirements": ["go2rtc-client==0.2.1"],
+  "requirements": ["go2rtc-client==0.3.0"],
   "single_config_entry": true
 }

homeassistant/components/go2rtc/server.py

@@ -6,13 +6,13 @@ from contextlib import suppress
 import logging
 from tempfile import NamedTemporaryFile
 
+from aiohttp import ClientSession
 from go2rtc_client import Go2RtcRestClient
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import HA_MANAGED_API_PORT, HA_MANAGED_URL
+from .const import HA_MANAGED_API_PORT, HA_MANAGED_UNIX_SOCKET, HA_MANAGED_URL
 
 _LOGGER = logging.getLogger(__name__)
 _TERMINATE_TIMEOUT = 5
@@ -23,14 +23,30 @@ _LOG_BUFFER_SIZE = 512
 _RESPAWN_COOLDOWN = 1
 
 # Default configuration for HA
-# - Api is listening only on localhost
+# - Unix socket for secure local communication
+# - Basic auth enabled, including local connections
+# - HTTP API only enabled when UI is enabled
 # - Enable rtsp for localhost only as ffmpeg needs it
 # - Clear default ice servers
 _GO2RTC_CONFIG_FORMAT = r"""# This file is managed by Home Assistant
 # Do not edit it manually
 
+app:
+  modules: {app_modules}
+
 api:
-  listen: "{api_ip}:{api_port}"
+  listen: "{listen_config}"
+  unix_listen: "{unix_socket}"
+  allow_paths: {api_allow_paths}
+  local_auth: true
+  username: {username}
+  password: {password}
+
+# ffmpeg needs the exec module
+# Restrict execution to only ffmpeg binary
+exec:
+  allow_paths:
+    - ffmpeg
 
 rtsp:
   listen: "127.0.0.1:18554"
@@ -40,6 +56,43 @@ webrtc:
   ice_servers: []
 """
 
+_APP_MODULES = (
+    "api",
+    "exec",  # Execution module for ffmpeg
+    "ffmpeg",
+    "http",
+    "mjpeg",
+    "onvif",
+    "rtmp",
+    "rtsp",
+    "srtp",
+    "webrtc",
+    "ws",
+)
+
+_API_ALLOW_PATHS = (
+    "/",  # UI static page and version control
+    "/api",  # Main API path
+    "/api/frame.jpeg",  # Snapshot functionality
+    "/api/schemes",  # Supported stream schemes
+    "/api/streams",  # Stream management
+    "/api/webrtc",  # Webrtc functionality
+    "/api/ws",  # Websocket functionality (e.g. webrtc candidates)
+)
+
+# Additional modules when UI is enabled
+_UI_APP_MODULES = (
+    *_APP_MODULES,
+    "debug",
+)
+# Additional api paths when UI is enabled
+_UI_API_ALLOW_PATHS = (
+    *_API_ALLOW_PATHS,
+    "/api/config",  # UI config view
+    "/api/log",  # UI log view
+    "/api/streams.dot",  # UI network view
+)
+
 _LOG_LEVEL_MAP = {
     "TRC": logging.DEBUG,
     "DBG": logging.DEBUG,
@@ -61,14 +114,40 @@ class Go2RTCWatchdogError(HomeAssistantError):
     """Raised on watchdog error."""
 
 
-def _create_temp_file(api_ip: str) -> str:
+def _format_list_for_yaml(items: tuple[str, ...]) -> str:
+    """Format a list of strings for yaml config."""
+    if not items:
+        return "[]"
+    formatted_items = ",".join(f'"{item}"' for item in items)
+    return f"[{formatted_items}]"
+
+
+def _create_temp_file(enable_ui: bool, username: str, password: str) -> str:
     """Create temporary config file."""
+    app_modules: tuple[str, ...] = _APP_MODULES
+    api_paths: tuple[str, ...] = _API_ALLOW_PATHS
+
+    if enable_ui:
+        app_modules = _UI_APP_MODULES
+        api_paths = _UI_API_ALLOW_PATHS
+        # Listen on all interfaces for allowing access from all ips
+        listen_config = f":{HA_MANAGED_API_PORT}"
+    else:
+        # Disable HTTP listening when UI is not enabled
+        # as HA does not use it.
+        listen_config = ""
+
     # Set delete=False to prevent the file from being deleted when the file is closed
     # Linux is clearing tmp folder on reboot, so no need to delete it manually
     with NamedTemporaryFile(prefix="go2rtc_", suffix=".yaml", delete=False) as file:
         file.write(
             _GO2RTC_CONFIG_FORMAT.format(
-                api_ip=api_ip, api_port=HA_MANAGED_API_PORT
+                listen_config=listen_config,
+                unix_socket=HA_MANAGED_UNIX_SOCKET,
+                app_modules=_format_list_for_yaml(app_modules),
+                api_allow_paths=_format_list_for_yaml(api_paths),
+                username=username,
+                password=password,
             ).encode()
         )
         return file.name
@@ -78,18 +157,25 @@ class Server:
     """Go2rtc server."""
 
     def __init__(
-        self, hass: HomeAssistant, binary: str, *, enable_ui: bool = False
+        self,
+        hass: HomeAssistant,
+        binary: str,
+        session: ClientSession,
+        *,
+        enable_ui: bool = False,
+        username: str,
+        password: str,
     ) -> None:
         """Initialize the server."""
         self._hass = hass
         self._binary = binary
+        self._session = session
+        self._enable_ui = enable_ui
+        self._username = username
+        self._password = password
         self._log_buffer: deque[str] = deque(maxlen=_LOG_BUFFER_SIZE)
         self._process: asyncio.subprocess.Process | None = None
         self._startup_complete = asyncio.Event()
-        self._api_ip = _LOCALHOST_IP
-        if enable_ui:
-            # Listen on all interfaces for allowing access from all ips
-            self._api_ip = ""
         self._watchdog_task: asyncio.Task | None = None
         self._watchdog_tasks: list[asyncio.Task] = []
 
@@ -104,7 +190,7 @@ class Server:
         """Start the server."""
         _LOGGER.debug("Starting go2rtc server")
         config_file = await self._hass.async_add_executor_job(
-            _create_temp_file, self._api_ip
+            _create_temp_file, self._enable_ui, self._username, self._password
         )
 
         self._startup_complete.clear()
@@ -133,7 +219,7 @@ class Server:
             raise Go2RTCServerStartError from err
 
         # Check the server version
-        client = Go2RtcRestClient(async_get_clientsession(self._hass), HA_MANAGED_URL)
+        client = Go2RtcRestClient(self._session, HA_MANAGED_URL)
         await client.validate_server_version()
 
     async def _log_output(self, process: asyncio.subprocess.Process) -> None:
@@ -205,7 +291,7 @@ class Server:
 
     async def _monitor_api(self) -> None:
         """Raise if the go2rtc process terminates."""
-        client = Go2RtcRestClient(async_get_clientsession(self._hass), HA_MANAGED_URL)
+        client = Go2RtcRestClient(self._session, HA_MANAGED_URL)
 
         _LOGGER.debug("Monitoring go2rtc API")
         try:

homeassistant/components/google_travel_time/sensor.py

@@ -97,7 +97,8 @@ SENSOR_DESCRIPTIONS = [
         key="duration",
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.DURATION,
-        native_unit_of_measurement=UnitOfTime.MINUTES,
+        native_unit_of_measurement=UnitOfTime.SECONDS,
+        suggested_unit_of_measurement=UnitOfTime.MINUTES,
     )
 ]
 
@@ -174,7 +175,7 @@ class GoogleTravelTimeSensor(SensorEntity):
         if self._route is None:
             return None
 
-        return round(self._route.duration.seconds / 60)
+        return self._route.duration.seconds
 
     @property
     def extra_state_attributes(self) -> dict[str, Any] | None:

homeassistant/components/hanna/__init__.py

@@ -0,0 +1,54 @@
+"""The Hanna Instruments integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from hanna_cloud import HannaCloudClient
+
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import HannaConfigEntry, HannaDataCoordinator
+
+PLATFORMS = [Platform.SENSOR]
+
+
+def _authenticate_and_get_devices(
+    api_client: HannaCloudClient,
+    email: str,
+    password: str,
+) -> list[dict[str, Any]]:
+    """Authenticate and get devices in a single executor job."""
+    api_client.authenticate(email, password)
+    return api_client.get_devices()
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: HannaConfigEntry) -> bool:
+    """Set up Hanna Instruments from a config entry."""
+    api_client = HannaCloudClient()
+    devices = await hass.async_add_executor_job(
+        _authenticate_and_get_devices,
+        api_client,
+        entry.data[CONF_EMAIL],
+        entry.data[CONF_PASSWORD],
+    )
+
+    # Create device coordinators
+    device_coordinators = {}
+    for device in devices:
+        coordinator = HannaDataCoordinator(hass, entry, device, api_client)
+        await coordinator.async_config_entry_first_refresh()
+        device_coordinators[coordinator.device_identifier] = coordinator
+
+    # Set runtime data
+    entry.runtime_data = device_coordinators
+
+    # Forward the setup to the platforms
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: HannaConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/hanna/config_flow.py

@@ -0,0 +1,62 @@
+"""Config flow for Hanna Instruments integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from hanna_cloud import AuthenticationError, HannaCloudClient
+from requests.exceptions import ConnectionError as RequestsConnectionError, Timeout
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HannaConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Hanna Instruments."""
+
+    VERSION = 1
+    data_schema = vol.Schema(
+        {vol.Required(CONF_EMAIL): str, vol.Required(CONF_PASSWORD): str}
+    )
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the setup flow."""
+
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            await self.async_set_unique_id(user_input[CONF_EMAIL])
+            self._abort_if_unique_id_configured()
+            client = HannaCloudClient()
+            try:
+                await self.hass.async_add_executor_job(
+                    client.authenticate,
+                    user_input[CONF_EMAIL],
+                    user_input[CONF_PASSWORD],
+                )
+            except (Timeout, RequestsConnectionError):
+                errors["base"] = "cannot_connect"
+            except AuthenticationError:
+                errors["base"] = "invalid_auth"
+
+            if not errors:
+                return self.async_create_entry(
+                    title=user_input[CONF_EMAIL],
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                self.data_schema, user_input
+            ),
+            errors=errors,
+        )

homeassistant/components/hanna/const.py

@@ -0,0 +1,3 @@
+"""Constants for the Hanna integration."""
+
+DOMAIN = "hanna"

homeassistant/components/hanna/coordinator.py

@@ -0,0 +1,72 @@
+"""Hanna Instruments data coordinator for Home Assistant.
+
+This module provides the data coordinator for fetching and managing Hanna Instruments
+sensor data.
+"""
+
+from datetime import timedelta
+import logging
+from typing import Any
+
+from hanna_cloud import HannaCloudClient
+from requests.exceptions import RequestException
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+type HannaConfigEntry = ConfigEntry[dict[str, HannaDataCoordinator]]
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HannaDataCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Coordinator for fetching Hanna sensor data."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: HannaConfigEntry,
+        device: dict[str, Any],
+        api_client: HannaCloudClient,
+    ) -> None:
+        """Initialize the Hanna data coordinator."""
+        self.api_client = api_client
+        self.device_data = device
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=f"{DOMAIN}_{self.device_identifier}",
+            config_entry=config_entry,
+            update_interval=timedelta(seconds=30),
+        )
+
+    @property
+    def device_identifier(self) -> str:
+        """Return the device identifier."""
+        return self.device_data["DID"]
+
+    def get_parameters(self) -> list[dict[str, Any]]:
+        """Get all parameters from the sensor data."""
+        return self.api_client.parameters
+
+    def get_parameter_value(self, key: str) -> Any:
+        """Get the value for a specific parameter."""
+        for parameter in self.get_parameters():
+            if parameter["name"] == key:
+                return parameter["value"]
+        return None
+
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Fetch latest sensor data from the Hanna API."""
+        try:
+            readings = await self.hass.async_add_executor_job(
+                self.api_client.get_last_device_reading, self.device_identifier
+            )
+        except RequestException as e:
+            raise UpdateFailed(f"Error communicating with Hanna API: {e}") from e
+        except (KeyError, IndexError) as e:
+            raise UpdateFailed(f"Error parsing Hanna API response: {e}") from e
+        return readings

homeassistant/components/hanna/entity.py

@@ -0,0 +1,28 @@
+"""Hanna Instruments entity base class for Home Assistant.
+
+This module provides the base entity class for Hanna Instruments entities.
+"""
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import HannaDataCoordinator
+
+
+class HannaEntity(CoordinatorEntity[HannaDataCoordinator]):
+    """Base class for Hanna entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: HannaDataCoordinator) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, coordinator.device_identifier)},
+            manufacturer=coordinator.device_data.get("manufacturer"),
+            model=coordinator.device_data.get("DM"),
+            name=coordinator.device_data.get("name"),
+            serial_number=coordinator.device_data.get("serial_number"),
+            sw_version=coordinator.device_data.get("sw_version"),
+        )

homeassistant/components/hanna/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "hanna",
+  "name": "Hanna",
+  "codeowners": ["@bestycame"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/hanna",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["hanna-cloud==0.0.6"]
+}

homeassistant/components/hanna/quality_scale.yaml

@@ -0,0 +1,70 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      This integration doesn't add actions.
+  appropriate-polling:
+    status: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions: done
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      Entities of this integration does not explicitly subscribe to events.
+  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: todo
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: |
+      This integration does not have any configuration parameters.
+  docs-installation-parameters: done
+  entity-unavailable: todo
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: done
+  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/hanna/sensor.py

@@ -0,0 +1,106 @@
+"""Hanna Instruments sensor integration for Home Assistant.
+
+This module provides sensor entities for various Hanna Instruments devices,
+including pH, ORP, temperature, and chemical sensors. It uses the Hanna API
+to fetch readings and updates them periodically.
+"""
+
+from __future__ import annotations
+
+import logging
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import UnitOfElectricPotential, UnitOfTemperature, UnitOfVolume
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
+
+from .coordinator import HannaConfigEntry, HannaDataCoordinator
+from .entity import HannaEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+SENSOR_DESCRIPTIONS = [
+    SensorEntityDescription(
+        key="ph",
+        translation_key="ph_value",
+        device_class=SensorDeviceClass.PH,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    SensorEntityDescription(
+        key="orp",
+        translation_key="chlorine_orp_value",
+        device_class=SensorDeviceClass.VOLTAGE,
+        native_unit_of_measurement=UnitOfElectricPotential.MILLIVOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    SensorEntityDescription(
+        key="temp",
+        translation_key="water_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    SensorEntityDescription(
+        key="airTemp",
+        translation_key="air_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    SensorEntityDescription(
+        key="acidBase",
+        translation_key="ph_acid_base_flow_rate",
+        icon="mdi:chemical-weapon",
+        device_class=SensorDeviceClass.VOLUME,
+        native_unit_of_measurement=UnitOfVolume.MILLILITERS,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+    SensorEntityDescription(
+        key="cl",
+        translation_key="chlorine_flow_rate",
+        icon="mdi:chemical-weapon",
+        device_class=SensorDeviceClass.VOLUME,
+        native_unit_of_measurement=UnitOfVolume.MILLILITERS,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: HannaConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Hanna sensors from a config entry."""
+    device_coordinators = entry.runtime_data
+
+    async_add_entities(
+        HannaSensor(coordinator, description)
+        for description in SENSOR_DESCRIPTIONS
+        for coordinator in device_coordinators.values()
+    )
+
+
+class HannaSensor(HannaEntity, SensorEntity):
+    """Representation of a Hanna sensor."""
+
+    def __init__(
+        self,
+        coordinator: HannaDataCoordinator,
+        description: SensorEntityDescription,
+    ) -> None:
+        """Initialize a Hanna sensor."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{coordinator.device_identifier}_{description.key}"
+        self.entity_description = description
+
+    @property
+    def native_value(self) -> StateType:
+        """Return the value reported by the sensor."""
+        return self.coordinator.get_parameter_value(self.entity_description.key)

homeassistant/components/hanna/strings.json

@@ -0,0 +1,44 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "Email address for your Hanna Cloud account",
+          "password": "Password for your Hanna Cloud account"
+        },
+        "description": "Enter your Hanna Cloud credentials"
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "air_temperature": {
+        "name": "Air temperature"
+      },
+      "chlorine_flow_rate": {
+        "name": "Chlorine flow rate"
+      },
+      "chlorine_orp_value": {
+        "name": "Chlorine ORP value"
+      },
+      "ph_acid_base_flow_rate": {
+        "name": "pH Acid/Base flow rate"
+      },
+      "water_temperature": {
+        "name": "Water temperature"
+      }
+    }
+  }
+}

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/huawei_lte/device_tracker.py

@@ -3,11 +3,8 @@
 from __future__ import annotations
 
 import logging
-import re
 from typing import Any, cast
 
-from stringcase import snakecase
-
 from homeassistant.components.device_tracker import (
     DOMAIN as DEVICE_TRACKER_DOMAIN,
     ScannerEntity,
@@ -18,6 +15,7 @@ from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util import snakecase
 
 from . import Router
 from .const import (
@@ -156,22 +154,6 @@ def async_add_new_entities(
     async_add_entities(new_entities, True)
 
 
-def _better_snakecase(text: str) -> str:
-    # Awaiting https://github.com/okunishinishi/python-stringcase/pull/18
-    if text == text.upper():
-        # All uppercase to all lowercase to get http for HTTP, not h_t_t_p
-        text = text.lower()
-    else:
-        # Three or more consecutive uppercase with middle part lowercased
-        # to get http_response for HTTPResponse, not h_t_t_p_response
-        text = re.sub(
-            r"([A-Z])([A-Z]+)([A-Z](?:[^A-Z]|$))",
-            lambda match: f"{match.group(1)}{match.group(2).lower()}{match.group(3)}",
-            text,
-        )
-    return cast(str, snakecase(text))
-
-
 class HuaweiLteScannerEntity(HuaweiLteBaseEntity, ScannerEntity):
     """Huawei LTE router scanner entity."""
 
@@ -235,7 +217,7 @@ class HuaweiLteScannerEntity(HuaweiLteBaseEntity, ScannerEntity):
             self._ip_address = (host.get("IpAddress") or "").split(";", 2)[0] or None
             self._hostname = host.get("HostName")
             self._extra_state_attributes = {
-                _better_snakecase(k): v
+                snakecase(k): v
                 for k, v in host.items()
                 if k
                 in {

homeassistant/components/huawei_lte/manifest.json

@@ -6,11 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/huawei_lte",
   "iot_class": "local_polling",
   "loggers": ["huawei_lte_api.Session"],
-  "requirements": [
-    "huawei-lte-api==1.11.0",
-    "stringcase==1.2.0",
-    "url-normalize==2.2.1"
-  ],
+  "requirements": ["huawei-lte-api==1.11.0", "url-normalize==2.2.1"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:InternetGatewayDevice:1",

homeassistant/components/huawei_lte/quality_scale.yaml

@@ -13,8 +13,8 @@ rules:
     status: todo
     comment: See if we can catch more specific exceptions in get_device_info.
   dependency-transparency:
-    status: todo
-    comment: stringcase is not built and published to PyPI from a public CI pipeline. huawei-lte-api is from https://gitlab.salamek.cz/Mirrors/huawei-lte-api, see https://github.com/Salamek/huawei-lte-api/issues/253
+    status: done
+    comment: huawei-lte-api is from https://gitlab.salamek.cz/Mirrors/huawei-lte-api, see https://github.com/Salamek/huawei-lte-api/issues/253
   docs-actions: done
   docs-high-level-description: done
   docs-installation-instructions: done
@@ -82,5 +82,4 @@ rules:
     status: exempt
     comment: Underlying huawei-lte-api does not use aiohttp or httpx, so this does not apply.
   strict-typing:
-    status: todo
-    comment: Integration is strictly typechecked already, and huawei-lte-api and url-normalize are in order. stringcase is not typed.
+    status: done

homeassistant/components/inkbird/manifest.json

@@ -62,5 +62,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/inkbird",
   "iot_class": "local_push",
-  "requirements": ["inkbird-ble==1.1.0"]
+  "requirements": ["inkbird-ble==1.1.1"]
 }

homeassistant/components/iron_os/strings.json

@@ -145,10 +145,10 @@
           "loop": "Loop",
           "off": "[%key:common::state::off%]",
           "seconds_1": "1 second",
-          "seconds_2": "2 second",
-          "seconds_3": "3 second",
-          "seconds_4": "4 second",
-          "seconds_5": "5 second"
+          "seconds_2": "2 seconds",
+          "seconds_3": "3 seconds",
+          "seconds_4": "4 seconds",
+          "seconds_5": "5 seconds"
         }
       },
       "min_dc_voltage_cells": {

homeassistant/components/kitchen_sink/__init__.py

@@ -11,6 +11,11 @@ from random import random
 
 import voluptuous as vol
 
+from homeassistant.components.labs import (
+    EVENT_LABS_UPDATED,
+    EventLabsUpdatedData,
+    async_is_preview_feature_enabled,
+)
 from homeassistant.components.recorder import DOMAIN as RECORDER_DOMAIN, get_instance
 from homeassistant.components.recorder.models import (
     StatisticData,
@@ -30,10 +35,14 @@ from homeassistant.const import (
     UnitOfTemperature,
     UnitOfVolume,
 )
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import Event, HomeAssistant, ServiceCall, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device_registry import DeviceEntry
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+from homeassistant.helpers.issue_registry import (
+    IssueSeverity,
+    async_create_issue,
+    async_delete_issue,
+)
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
 from homeassistant.util.unit_conversion import (
@@ -110,6 +119,23 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     # Notify backup listeners
     hass.async_create_task(_notify_backup_listeners(hass), eager_start=False)
 
+    # Subscribe to labs feature updates for kitchen_sink preview repair
+    @callback
+    def _async_labs_updated(event: Event[EventLabsUpdatedData]) -> None:
+        """Handle labs feature update event."""
+        if (
+            event.data["domain"] == "kitchen_sink"
+            and event.data["preview_feature"] == "special_repair"
+        ):
+            _async_update_special_repair(hass)
+
+    entry.async_on_unload(
+        hass.bus.async_listen(EVENT_LABS_UPDATED, _async_labs_updated)
+    )
+
+    # Check if lab feature is currently enabled and create repair if so
+    _async_update_special_repair(hass)
+
     return True
 
 
@@ -137,6 +163,27 @@ async def async_remove_config_entry_device(
     return True
 
 
+@callback
+def _async_update_special_repair(hass: HomeAssistant) -> None:
+    """Create or delete the special repair issue.
+
+    Creates a repair issue when the special_repair lab feature is enabled,
+    and deletes it when disabled. This demonstrates how lab features can interact
+    with Home Assistant's repair system.
+    """
+    if async_is_preview_feature_enabled(hass, DOMAIN, "special_repair"):
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "kitchen_sink_special_repair_issue",
+            is_fixable=False,
+            severity=IssueSeverity.WARNING,
+            translation_key="special_repair",
+        )
+    else:
+        async_delete_issue(hass, DOMAIN, "kitchen_sink_special_repair_issue")
+
+
 async def _notify_backup_listeners(hass: HomeAssistant) -> None:
     for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
         listener()

homeassistant/components/kitchen_sink/manifest.json

@@ -5,6 +5,13 @@
   "codeowners": ["@home-assistant/core"],
   "documentation": "https://www.home-assistant.io/integrations/kitchen_sink",
   "iot_class": "calculated",
+  "preview_features": {
+    "special_repair": {
+      "feedback_url": "https://community.home-assistant.io",
+      "learn_more_url": "https://www.home-assistant.io/integrations/kitchen_sink",
+      "report_issue_url": "https://github.com/home-assistant/core/issues/new?template=bug_report.yml&integration_link=https://www.home-assistant.io/integrations/kitchen_sink&integration_name=Kitchen%20Sink"
+    }
+  },
   "quality_scale": "internal",
   "single_config_entry": true
 }

homeassistant/components/kitchen_sink/strings.json

@@ -71,6 +71,10 @@
       },
       "title": "The blinker fluid is empty and needs to be refilled"
     },
+    "special_repair": {
+      "description": "This is a special repair created by a preview feature! This demonstrates how lab features can interact with the Home Assistant repair system. You can disable this by turning off the kitchen sink special repair feature in Settings > System > Labs.",
+      "title": "Special repair feature preview"
+    },
     "transmogrifier_deprecated": {
       "description": "The transmogrifier component is now deprecated due to the lack of local control available in the new API",
       "title": "The transmogrifier component is deprecated"
@@ -103,6 +107,14 @@
       }
     }
   },
+  "preview_features": {
+    "special_repair": {
+      "description": "Creates a **special repair issue** when enabled.\n\nThis demonstrates how lab features can interact with other Home Assistant integrations.",
+      "disable_confirmation": "This will remove the special repair issue. Don't worry, this is just a demonstration feature.",
+      "enable_confirmation": "This will create a special repair issue to demonstrate Labs preview features. This is just an example and won't affect your actual system.",
+      "name": "Special repair"
+    }
+  },
   "services": {
     "test_service_1": {
       "description": "Fake action for testing",

homeassistant/components/knx/manifest.json

@@ -11,7 +11,7 @@
   "loggers": ["xknx", "xknxproject"],
   "quality_scale": "silver",
   "requirements": [
-    "xknx==3.10.1",
+    "xknx==3.11.0",
     "xknxproject==3.8.2",
     "knx-frontend==2025.10.31.195356"
   ],

homeassistant/components/knx/storage/entity_store_schema.py

@@ -279,7 +279,7 @@ LIGHT_KNX_SCHEMA = AllSerializeFirst(
                     translation_key="hsv_addresses",
                     schema={
                         vol.Required(CONF_GA_HUE): GASelector(
-                            write_required=True, valid_dpt="5.001"
+                            write_required=True, valid_dpt="5.003"
                         ),
                         vol.Required(CONF_GA_SATURATION): GASelector(
                             write_required=True, valid_dpt="5.001"

homeassistant/components/labs/__init__.py

@@ -0,0 +1,310 @@
+"""The Home Assistant Labs integration.
+
+This integration provides preview features that can be toggled on/off by users.
+Integrations can register lab preview features in their manifest.json which will appear
+in the Home Assistant Labs UI for users to enable or disable.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.components.backup import async_get_manager
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.generated.labs import LABS_PREVIEW_FEATURES
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.storage import Store
+from homeassistant.helpers.typing import ConfigType
+from homeassistant.loader import async_get_custom_components
+
+from .const import (
+    DOMAIN,
+    EVENT_LABS_UPDATED,
+    LABS_DATA,
+    STORAGE_KEY,
+    STORAGE_VERSION,
+    EventLabsUpdatedData,
+    LabPreviewFeature,
+    LabsData,
+    LabsStoreData,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+__all__ = [
+    "EVENT_LABS_UPDATED",
+    "EventLabsUpdatedData",
+    "async_is_preview_feature_enabled",
+]
+
+
+class LabsStorage(Store[LabsStoreData]):
+    """Custom Store for Labs that converts between runtime and storage formats.
+
+    Runtime format: {"preview_feature_status": {(domain, preview_feature)}}
+    Storage format: {"preview_feature_status": [{"domain": str, "preview_feature": str}]}
+
+    Only enabled features are saved to storage - if stored, it's enabled.
+    """
+
+    async def _async_load_data(self) -> LabsStoreData | None:
+        """Load data and convert from storage format to runtime format."""
+        raw_data = await super()._async_load_data()
+        if raw_data is None:
+            return None
+
+        status_list = raw_data.get("preview_feature_status", [])
+
+        # Convert list of objects to runtime set - if stored, it's enabled
+        return {
+            "preview_feature_status": {
+                (item["domain"], item["preview_feature"]) for item in status_list
+            }
+        }
+
+    def _write_data(self, path: str, data: dict) -> None:
+        """Convert from runtime format to storage format and write.
+
+        Only saves enabled features - disabled is the default.
+        """
+        # Extract the actual data (has version/key wrapper)
+        actual_data = data.get("data", data)
+
+        # Check if this is Labs data (has preview_feature_status key)
+        if "preview_feature_status" not in actual_data:
+            # Not Labs data, write as-is
+            super()._write_data(path, data)
+            return
+
+        preview_status = actual_data["preview_feature_status"]
+
+        # Convert from runtime format (set of tuples) to storage format (list of dicts)
+        status_list = [
+            {"domain": domain, "preview_feature": preview_feature}
+            for domain, preview_feature in preview_status
+        ]
+
+        # Build the final data structure with converted format
+        data_copy = data.copy()
+        data_copy["data"] = {"preview_feature_status": status_list}
+
+        super()._write_data(path, data_copy)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Labs component."""
+    store = LabsStorage(hass, STORAGE_VERSION, STORAGE_KEY, private=True)
+    data = await store.async_load()
+
+    if data is None:
+        data = {"preview_feature_status": set()}
+
+    # Scan ALL integrations for lab preview features (loaded or not)
+    lab_preview_features = await _async_scan_all_preview_features(hass)
+
+    # Clean up preview features that no longer exist
+    if lab_preview_features:
+        valid_keys = {
+            (pf.domain, pf.preview_feature) for pf in lab_preview_features.values()
+        }
+        stale_keys = data["preview_feature_status"] - valid_keys
+
+        if stale_keys:
+            _LOGGER.debug(
+                "Removing %d stale preview features: %s",
+                len(stale_keys),
+                stale_keys,
+            )
+            data["preview_feature_status"] -= stale_keys
+
+            await store.async_save(data)
+
+    hass.data[LABS_DATA] = LabsData(
+        store=store,
+        data=data,
+        preview_features=lab_preview_features,
+    )
+
+    websocket_api.async_register_command(hass, websocket_list_preview_features)
+    websocket_api.async_register_command(hass, websocket_update_preview_feature)
+
+    return True
+
+
+def _populate_preview_features(
+    preview_features: dict[str, LabPreviewFeature],
+    domain: str,
+    labs_preview_features: dict[str, dict[str, str]],
+    is_built_in: bool = True,
+) -> None:
+    """Populate preview features dictionary from integration preview_features.
+
+    Args:
+        preview_features: Dictionary to populate
+        domain: Integration domain
+        labs_preview_features: Dictionary of preview feature definitions from manifest
+        is_built_in: Whether this is a built-in integration
+    """
+    for preview_feature_key, preview_feature_data in labs_preview_features.items():
+        preview_feature = LabPreviewFeature(
+            domain=domain,
+            preview_feature=preview_feature_key,
+            is_built_in=is_built_in,
+            feedback_url=preview_feature_data.get("feedback_url"),
+            learn_more_url=preview_feature_data.get("learn_more_url"),
+            report_issue_url=preview_feature_data.get("report_issue_url"),
+        )
+        preview_features[preview_feature.full_key] = preview_feature
+
+
+async def _async_scan_all_preview_features(
+    hass: HomeAssistant,
+) -> dict[str, LabPreviewFeature]:
+    """Scan ALL available integrations for lab preview features (loaded or not)."""
+    preview_features: dict[str, LabPreviewFeature] = {}
+
+    # Load pre-generated built-in lab preview features (already includes all data)
+    for domain, domain_preview_features in LABS_PREVIEW_FEATURES.items():
+        _populate_preview_features(
+            preview_features, domain, domain_preview_features, is_built_in=True
+        )
+
+    # Scan custom components
+    custom_integrations = await async_get_custom_components(hass)
+    _LOGGER.debug(
+        "Loaded %d built-in + scanning %d custom integrations for lab preview features",
+        len(preview_features),
+        len(custom_integrations),
+    )
+
+    for integration in custom_integrations.values():
+        if labs_preview_features := integration.preview_features:
+            _populate_preview_features(
+                preview_features,
+                integration.domain,
+                labs_preview_features,
+                is_built_in=False,
+            )
+
+    _LOGGER.debug("Loaded %d total lab preview features", len(preview_features))
+    return preview_features
+
+
+@callback
+def async_is_preview_feature_enabled(
+    hass: HomeAssistant, domain: str, preview_feature: str
+) -> bool:
+    """Check if a lab preview feature is enabled.
+
+    Args:
+        hass: HomeAssistant instance
+        domain: Integration domain
+        preview_feature: Preview feature name
+
+    Returns:
+        True if the preview feature is enabled, False otherwise
+    """
+    if LABS_DATA not in hass.data:
+        return False
+
+    labs_data = hass.data[LABS_DATA]
+    return (domain, preview_feature) in labs_data.data["preview_feature_status"]
+
+
+@callback
+@websocket_api.require_admin
+@websocket_api.websocket_command({vol.Required("type"): "labs/list"})
+def websocket_list_preview_features(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """List all lab preview features filtered by loaded integrations."""
+    labs_data = hass.data[LABS_DATA]
+    loaded_components = hass.config.components
+
+    preview_features: list[dict[str, Any]] = [
+        preview_feature.to_dict(
+            (preview_feature.domain, preview_feature.preview_feature)
+            in labs_data.data["preview_feature_status"]
+        )
+        for preview_feature_key, preview_feature in labs_data.preview_features.items()
+        if preview_feature.domain in loaded_components
+    ]
+
+    connection.send_result(msg["id"], {"features": preview_features})
+
+
+@websocket_api.require_admin
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "labs/update",
+        vol.Required("domain"): str,
+        vol.Required("preview_feature"): str,
+        vol.Required("enabled"): bool,
+        vol.Optional("create_backup", default=False): bool,
+    }
+)
+@websocket_api.async_response
+async def websocket_update_preview_feature(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Update a lab preview feature state."""
+    domain = msg["domain"]
+    preview_feature = msg["preview_feature"]
+    enabled = msg["enabled"]
+    create_backup = msg["create_backup"]
+
+    labs_data = hass.data[LABS_DATA]
+
+    # Build preview_feature_id for lookup
+    preview_feature_id = f"{domain}.{preview_feature}"
+
+    # Validate preview feature exists
+    if preview_feature_id not in labs_data.preview_features:
+        connection.send_error(
+            msg["id"],
+            websocket_api.ERR_NOT_FOUND,
+            f"Preview feature {preview_feature_id} not found",
+        )
+        return
+
+    # Create backup if requested and enabling
+    if create_backup and enabled:
+        try:
+            backup_manager = async_get_manager(hass)
+            await backup_manager.async_create_automatic_backup()
+        except Exception as err:  # noqa: BLE001 - websocket handlers can catch broad exceptions
+            connection.send_error(
+                msg["id"],
+                websocket_api.ERR_UNKNOWN_ERROR,
+                f"Error creating backup: {err}",
+            )
+            return
+
+    # Update storage (only store enabled features, remove if disabled)
+    if enabled:
+        labs_data.data["preview_feature_status"].add((domain, preview_feature))
+    else:
+        labs_data.data["preview_feature_status"].discard((domain, preview_feature))
+
+    # Save changes immediately
+    await labs_data.store.async_save(labs_data.data)
+
+    # Fire event
+    event_data: EventLabsUpdatedData = {
+        "domain": domain,
+        "preview_feature": preview_feature,
+        "enabled": enabled,
+    }
+    hass.bus.async_fire(EVENT_LABS_UPDATED, event_data)
+
+    connection.send_result(msg["id"])

homeassistant/components/labs/const.py

@@ -0,0 +1,77 @@
+"""Constants for the Home Assistant Labs integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, TypedDict
+
+from homeassistant.util.hass_dict import HassKey
+
+if TYPE_CHECKING:
+    from homeassistant.helpers.storage import Store
+
+DOMAIN = "labs"
+
+STORAGE_KEY = "core.labs"
+STORAGE_VERSION = 1
+
+EVENT_LABS_UPDATED = "labs_updated"
+
+
+class EventLabsUpdatedData(TypedDict):
+    """Event data for labs_updated event."""
+
+    domain: str
+    preview_feature: str
+    enabled: bool
+
+
+@dataclass(frozen=True, kw_only=True, slots=True)
+class LabPreviewFeature:
+    """Lab preview feature definition."""
+
+    domain: str
+    preview_feature: str
+    is_built_in: bool = True
+    feedback_url: str | None = None
+    learn_more_url: str | None = None
+    report_issue_url: str | None = None
+
+    @property
+    def full_key(self) -> str:
+        """Return the full key for the preview feature (domain.preview_feature)."""
+        return f"{self.domain}.{self.preview_feature}"
+
+    def to_dict(self, enabled: bool) -> dict[str, str | bool | None]:
+        """Return a serialized version of the preview feature.
+
+        Args:
+            enabled: Whether the preview feature is currently enabled
+
+        Returns:
+            Dictionary with preview feature data including enabled status
+        """
+        return {
+            "preview_feature": self.preview_feature,
+            "domain": self.domain,
+            "enabled": enabled,
+            "is_built_in": self.is_built_in,
+            "feedback_url": self.feedback_url,
+            "learn_more_url": self.learn_more_url,
+            "report_issue_url": self.report_issue_url,
+        }
+
+
+type LabsStoreData = dict[str, set[tuple[str, str]]]
+
+
+@dataclass
+class LabsData:
+    """Storage class for Labs global data."""
+
+    store: Store[LabsStoreData]
+    data: LabsStoreData
+    preview_features: dict[str, LabPreviewFeature] = field(default_factory=dict)
+
+
+LABS_DATA: HassKey[LabsData] = HassKey(DOMAIN)

homeassistant/components/labs/manifest.json

@@ -0,0 +1,9 @@
+{
+  "domain": "labs",
+  "name": "Home Assistant Labs",
+  "codeowners": ["@home-assistant/core"],
+  "documentation": "https://www.home-assistant.io/integrations/labs",
+  "integration_type": "system",
+  "iot_class": "calculated",
+  "quality_scale": "internal"
+}

homeassistant/components/labs/strings.json

@@ -0,0 +1,3 @@
+{
+  "title": "Home Assistant Labs"
+}

homeassistant/components/lamarzocco/__init__.py

@@ -15,16 +15,20 @@ from pylamarzocco.const import FirmwareType
 from pylamarzocco.exceptions import AuthFail, RequestNotSuccessful
 from pylamarzocco.util import InstallationKey, generate_installation_key
 
-from homeassistant.components.bluetooth import async_discovered_service_info
+from homeassistant.components.bluetooth import (
+    async_ble_device_from_address,
+    async_discovered_service_info,
+)
 from homeassistant.const import (
     CONF_MAC,
     CONF_PASSWORD,
     CONF_TOKEN,
     CONF_USERNAME,
+    EVENT_HOMEASSISTANT_STOP,
     Platform,
     __version__,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
@@ -99,7 +103,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: LaMarzoccoConfigEntry) -
     # initialize Bluetooth
     bluetooth_client: LaMarzoccoBluetoothClient | None = None
     if entry.options.get(CONF_USE_BLUETOOTH, True) and (
-        token := settings.ble_auth_token
+        token := (entry.data.get(CONF_TOKEN) or settings.ble_auth_token)
     ):
         if CONF_MAC not in entry.data:
             for discovery_info in async_discovered_service_info(hass):
@@ -108,7 +112,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: LaMarzoccoConfigEntry) -
                     and name.startswith(BT_MODEL_PREFIXES)
                     and name.split("_")[1] == serial
                 ):
-                    _LOGGER.debug("Found Bluetooth device, configuring with Bluetooth")
+                    _LOGGER.info("Found lamarzocco Bluetooth device, adding to entry")
                     # found a device, add MAC address to config entry
                     hass.config_entries.async_update_entry(
                         entry,
@@ -118,22 +122,29 @@ async def async_setup_entry(hass: HomeAssistant, entry: LaMarzoccoConfigEntry) -
                         },
                     )
 
-        if not entry.data[CONF_TOKEN]:
-            # update the token in the config entry
-            hass.config_entries.async_update_entry(
-                entry,
-                data={
-                    **entry.data,
-                    CONF_TOKEN: token,
-                },
-            )
-
         if CONF_MAC in entry.data:
-            _LOGGER.debug("Initializing Bluetooth device")
-            bluetooth_client = LaMarzoccoBluetoothClient(
-                address_or_ble_device=entry.data[CONF_MAC],
-                ble_token=token,
-            )
+            ble_device = async_ble_device_from_address(hass, entry.data[CONF_MAC])
+            if ble_device:
+                _LOGGER.info("Setting up lamarzocco with Bluetooth")
+                bluetooth_client = LaMarzoccoBluetoothClient(
+                    ble_device=ble_device,
+                    ble_token=token,
+                )
+
+                async def disconnect_bluetooth(_: Event) -> None:
+                    """Stop push updates when hass stops."""
+                    await bluetooth_client.disconnect()
+
+                entry.async_on_unload(
+                    hass.bus.async_listen_once(
+                        EVENT_HOMEASSISTANT_STOP, disconnect_bluetooth
+                    )
+                )
+                entry.async_on_unload(bluetooth_client.disconnect)
+            else:
+                _LOGGER.info(
+                    "Bluetooth device not found during lamarzocco setup, continuing with cloud only"
+                )
 
     device = LaMarzoccoMachine(
         serial_number=entry.unique_id,

homeassistant/components/lamarzocco/coordinator.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 from abc import abstractmethod
+from asyncio import Task
+from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
 from datetime import timedelta
 import logging
@@ -13,7 +15,7 @@ from pylamarzocco.exceptions import AuthFail, RequestNotSuccessful
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -44,7 +46,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,10 +66,19 @@ class LaMarzoccoUpdateCoordinator(DataUpdateCoordinator[None]):
         self.device = device
         self.cloud_client = cloud_client
 
-    async def _async_update_data(self) -> None:
-        """Do the data update."""
+    @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 __handle_internal_update(
+        self, func: Callable[[], Coroutine[Any, Any, None]]
+    ) -> None:
+        """Handle update with error handling."""
         try:
-            await self._internal_async_update_data()
+            await func()
         except AuthFail as ex:
             _LOGGER.debug("Authentication failed", exc_info=True)
             raise ConfigEntryAuthFailed(
@@ -79,6 +90,17 @@ class LaMarzoccoUpdateCoordinator(DataUpdateCoordinator[None]):
                 translation_domain=DOMAIN, translation_key="api_error"
             ) from ex
 
+    async def _async_setup(self) -> None:
+        """Set up coordinator."""
+        await self.__handle_internal_update(self._internal_async_setup)
+
+    async def _async_update_data(self) -> None:
+        """Do the data update."""
+        await self.__handle_internal_update(self._internal_async_update_data)
+
+    async def _internal_async_setup(self) -> None:
+        """Actual setup logic."""
+
     @abstractmethod
     async def _internal_async_update_data(self) -> None:
         """Actual data update logic."""
@@ -89,19 +111,23 @@ class LaMarzoccoConfigUpdateCoordinator(LaMarzoccoUpdateCoordinator):
 
     cloud_client: LaMarzoccoCloudClient
 
+    async def _internal_async_setup(self) -> None:
+        """Set up the coordinator."""
+        await self.cloud_client.async_get_access_token()
+        await self.device.get_dashboard()
+        _LOGGER.debug("Current status: %s", self.device.dashboard.to_dict())
+
     async def _internal_async_update_data(self) -> None:
         """Fetch data from API endpoint."""
 
         # 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,16 +146,19 @@ class LaMarzoccoConfigUpdateCoordinator(LaMarzoccoUpdateCoordinator):
 
         _LOGGER.debug("Init WebSocket in background task")
 
-        self.websocket_terminated = False
         self.async_update_listeners()
 
+        @callback
+        def update_callback(_: Any | None = None) -> None:
+            _LOGGER.debug("Current status: %s", self.device.dashboard.to_dict())
+            self.async_set_updated_data(None)
+
         await self.device.connect_dashboard_websocket(
-            update_callback=lambda _: self.async_set_updated_data(None),
+            update_callback=update_callback,
             connect_callback=self.async_update_listeners,
             disconnect_callback=self.async_update_listeners,
         )
 
-        self.websocket_terminated = True
         self.async_update_listeners()
 
 

homeassistant/components/lamarzocco/manifest.json

@@ -37,5 +37,5 @@
   "iot_class": "cloud_push",
   "loggers": ["pylamarzocco"],
   "quality_scale": "platinum",
-  "requirements": ["pylamarzocco==2.1.3"]
+  "requirements": ["pylamarzocco==2.2.0"]
 }

homeassistant/components/lcn/binary_sensor.py

@@ -73,14 +73,17 @@ class LcnBinarySensor(LcnEntity, BinarySensorEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_binary_sensors(
-            SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_binary_sensors(
+                SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusBinSensors):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.bin_sensor_port.value)
         self.async_write_ha_state()

homeassistant/components/lcn/climate.py

@@ -171,20 +171,22 @@ class LcnClimate(LcnEntity, ClimateEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await asyncio.gather(
-            self.device_connection.request_status_variable(
-                self.variable, SCAN_INTERVAL.seconds
-            ),
-            self.device_connection.request_status_variable(
-                self.setpoint, SCAN_INTERVAL.seconds
-            ),
+        self._attr_available = any(
+            await asyncio.gather(
+                self.device_connection.request_status_variable(
+                    self.variable, SCAN_INTERVAL.seconds
+                ),
+                self.device_connection.request_status_variable(
+                    self.setpoint, SCAN_INTERVAL.seconds
+                ),
+            )
         )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set temperature value when LCN input object is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusVar):
             return
-
+        self._attr_available = True
         if input_obj.get_var() == self.variable:
             self._attr_current_temperature = float(
                 input_obj.get_value().to_var_unit(self.unit)

homeassistant/components/lcn/cover.py

@@ -133,13 +133,15 @@ class LcnOutputsCover(LcnEntity, CoverEntity):
     async def async_update(self) -> None:
         """Update the state of the entity."""
         if not self.device_connection.is_group:
-            await asyncio.gather(
-                self.device_connection.request_status_output(
-                    pypck.lcn_defs.OutputPort["OUTPUTUP"], SCAN_INTERVAL.seconds
-                ),
-                self.device_connection.request_status_output(
-                    pypck.lcn_defs.OutputPort["OUTPUTDOWN"], SCAN_INTERVAL.seconds
-                ),
+            self._attr_available = any(
+                await asyncio.gather(
+                    self.device_connection.request_status_output(
+                        pypck.lcn_defs.OutputPort["OUTPUTUP"], SCAN_INTERVAL.seconds
+                    ),
+                    self.device_connection.request_status_output(
+                        pypck.lcn_defs.OutputPort["OUTPUTDOWN"], SCAN_INTERVAL.seconds
+                    ),
+                )
             )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -149,7 +151,7 @@ class LcnOutputsCover(LcnEntity, CoverEntity):
             or input_obj.get_output_id() not in self.output_ids
         ):
             return
-
+        self._attr_available = True
         if input_obj.get_percent() > 0:  # motor is on
             if input_obj.get_output_id() == self.output_ids[0]:
                 self._attr_is_opening = True
@@ -272,11 +274,12 @@ class LcnRelayCover(LcnEntity, CoverEntity):
                     self.motor, self.positioning_mode, SCAN_INTERVAL.seconds
                 )
             )
-        await asyncio.gather(*coros)
+        self._attr_available = any(await asyncio.gather(*coros))
 
     def input_received(self, input_obj: InputType) -> None:
         """Set cover states when LCN input object (command) is received."""
         if isinstance(input_obj, pypck.inputs.ModStatusRelays):
+            self._attr_available = True
             self._attr_is_opening = input_obj.is_opening(self.motor.value)
             self._attr_is_closing = input_obj.is_closing(self.motor.value)
 
@@ -293,6 +296,7 @@ class LcnRelayCover(LcnEntity, CoverEntity):
             )
             and input_obj.motor == self.motor.value
         ):
+            self._attr_available = True
             self._attr_current_cover_position = int(input_obj.position)
             if self._attr_current_cover_position in [0, 100]:
                 self._attr_is_opening = False

homeassistant/components/lcn/light.py

@@ -149,8 +149,11 @@ class LcnOutputLight(LcnEntity, LightEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_output(
-            self.output, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_output(
+                self.output, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -160,7 +163,7 @@ class LcnOutputLight(LcnEntity, LightEntity):
             or input_obj.get_output_id() != self.output.value
         ):
             return
-
+        self._attr_available = True
         percent = input_obj.get_percent()
         self._attr_brightness = value_to_brightness(BRIGHTNESS_SCALE, percent)
         self._attr_is_on = bool(percent)
@@ -200,12 +203,15 @@ class LcnRelayLight(LcnEntity, LightEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+        self._attr_available = (
+            await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+            is not None
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set light state when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusRelays):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.output.value)
         self.async_write_ha_state()

homeassistant/components/lcn/quality_scale.yaml

@@ -25,7 +25,7 @@ rules:
     status: exempt
     comment: Integration has no configuration parameters
   docs-installation-parameters: done
-  entity-unavailable: todo
+  entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done

homeassistant/components/lcn/sensor.py

@@ -133,8 +133,11 @@ class LcnVariableSensor(LcnEntity, SensorEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_variable(
-            self.variable, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_variable(
+                self.variable, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -144,7 +147,7 @@ class LcnVariableSensor(LcnEntity, SensorEntity):
             or input_obj.get_var() != self.variable
         ):
             return
-
+        self._attr_available = True
         is_regulator = self.variable.name in SETPOINTS
         self._attr_native_value = input_obj.get_value().to_var_unit(
             self.unit, is_regulator
@@ -171,15 +174,18 @@ class LcnLedLogicSensor(LcnEntity, SensorEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_led_and_logic_ops(
-            SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_led_and_logic_ops(
+                SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set sensor value when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusLedsAndLogicOps):
             return
-
+        self._attr_available = True
         if self.source in pypck.lcn_defs.LedPort:
             self._attr_native_value = input_obj.get_led_state(
                 self.source.value

homeassistant/components/lcn/switch.py

@@ -95,8 +95,11 @@ class LcnOutputSwitch(LcnEntity, SwitchEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_output(
-            self.output, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_output(
+                self.output, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -106,7 +109,7 @@ class LcnOutputSwitch(LcnEntity, SwitchEntity):
             or input_obj.get_output_id() != self.output.value
         ):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_percent() > 0
         self.async_write_ha_state()
 
@@ -142,13 +145,16 @@ class LcnRelaySwitch(LcnEntity, SwitchEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+        self._attr_available = (
+            await self.device_connection.request_status_relays(SCAN_INTERVAL.seconds)
+            is not None
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
         if not isinstance(input_obj, pypck.inputs.ModStatusRelays):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.output.value)
         self.async_write_ha_state()
 
@@ -183,8 +189,11 @@ class LcnRegulatorLockSwitch(LcnEntity, SwitchEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_variable(
-            self.setpoint_variable, SCAN_INTERVAL.seconds
+        self._attr_available = (
+            await self.device_connection.request_status_variable(
+                self.setpoint_variable, SCAN_INTERVAL.seconds
+            )
+            is not None
         )
 
     def input_received(self, input_obj: InputType) -> None:
@@ -194,7 +203,7 @@ class LcnRegulatorLockSwitch(LcnEntity, SwitchEntity):
             or input_obj.get_var() != self.setpoint_variable
         ):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_value().is_locked_regulator()
         self.async_write_ha_state()
 
@@ -236,7 +245,12 @@ class LcnKeyLockSwitch(LcnEntity, SwitchEntity):
 
     async def async_update(self) -> None:
         """Update the state of the entity."""
-        await self.device_connection.request_status_locked_keys(SCAN_INTERVAL.seconds)
+        self._attr_available = (
+            await self.device_connection.request_status_locked_keys(
+                SCAN_INTERVAL.seconds
+            )
+            is not None
+        )
 
     def input_received(self, input_obj: InputType) -> None:
         """Set switch state when LCN input object (command) is received."""
@@ -245,6 +259,6 @@ class LcnKeyLockSwitch(LcnEntity, SwitchEntity):
             or self.key not in pypck.lcn_defs.Key
         ):
             return
-
+        self._attr_available = True
         self._attr_is_on = input_obj.get_state(self.table_id, self.key_id)
         self.async_write_ha_state()

homeassistant/components/lifx/light.py

@@ -341,7 +341,7 @@ class LIFXLight(LIFXEntity, LightEntity):
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""
         self.async_on_remove(
-            self.manager.async_register_entity(self.entity_id, self.entry.entry_id)
+            self.manager.async_register_entity(self.entity_id, self.coordinator)
         )
         return await super().async_added_to_hass()
 

homeassistant/components/lifx/manager.py

@@ -34,7 +34,7 @@ from homeassistant.helpers.target import (
 )
 
 from .const import _ATTR_COLOR_TEMP, ATTR_THEME, DOMAIN
-from .coordinator import LIFXConfigEntry, LIFXUpdateCoordinator
+from .coordinator import LIFXUpdateCoordinator
 from .util import convert_8_to_16, find_hsbk
 
 if TYPE_CHECKING:
@@ -243,7 +243,7 @@ class LIFXManager:
         """Initialize the manager."""
         self.hass = hass
         self.effects_conductor = aiolifx_effects.Conductor(hass.loop)
-        self.entry_id_to_entity_id: dict[str, str] = {}
+        self.entity_id_to_coordinator: dict[str, LIFXUpdateCoordinator] = {}
 
     @callback
     def async_unload(self) -> None:
@@ -253,15 +253,15 @@ class LIFXManager:
 
     @callback
     def async_register_entity(
-        self, entity_id: str, entry_id: str
+        self, entity_id: str, coordinator: LIFXUpdateCoordinator
     ) -> Callable[[], None]:
         """Register an entity to the config entry id."""
-        self.entry_id_to_entity_id[entry_id] = entity_id
+        self.entity_id_to_coordinator[entity_id] = coordinator
 
         @callback
         def unregister_entity() -> None:
             """Unregister entity when it is being destroyed."""
-            self.entry_id_to_entity_id.pop(entry_id)
+            self.entity_id_to_coordinator.pop(entity_id)
 
         return unregister_entity
 
@@ -499,10 +499,11 @@ class LIFXManager:
         coordinators: list[LIFXUpdateCoordinator] = []
         bulbs: list[Light] = []
 
-        entry: LIFXConfigEntry
-        for entry in self.hass.config_entries.async_loaded_entries(DOMAIN):
-            if self.entry_id_to_entity_id[entry.entry_id] in entity_ids:
-                coordinators.append(entry.runtime_data)
-                bulbs.append(entry.runtime_data.device)
+        coordinators = [
+            coordinator
+            for entity_id, coordinator in self.entity_id_to_coordinator.items()
+            if entity_id in entity_ids
+        ]
+        bulbs = [coordinator.device for coordinator in coordinators]
         if start_effect_func := self._effect_dispatch.get(service):
             await start_effect_func(self, bulbs, coordinators, **kwargs)

homeassistant/components/mastodon/const.py

@@ -14,6 +14,7 @@ DEFAULT_NAME: Final = "Mastodon"
 
 ATTR_STATUS = "status"
 ATTR_VISIBILITY = "visibility"
+ATTR_IDEMPOTENCY_KEY = "idempotency_key"
 ATTR_CONTENT_WARNING = "content_warning"
 ATTR_MEDIA_WARNING = "media_warning"
 ATTR_MEDIA = "media"

homeassistant/components/mastodon/services.py

@@ -15,6 +15,7 @@ from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 
 from .const import (
     ATTR_CONTENT_WARNING,
+    ATTR_IDEMPOTENCY_KEY,
     ATTR_LANGUAGE,
     ATTR_MEDIA,
     ATTR_MEDIA_DESCRIPTION,
@@ -42,6 +43,7 @@ SERVICE_POST_SCHEMA = vol.Schema(
         vol.Required(ATTR_CONFIG_ENTRY_ID): str,
         vol.Required(ATTR_STATUS): str,
         vol.Optional(ATTR_VISIBILITY): vol.In([x.lower() for x in StatusVisibility]),
+        vol.Optional(ATTR_IDEMPOTENCY_KEY): str,
         vol.Optional(ATTR_CONTENT_WARNING): str,
         vol.Optional(ATTR_LANGUAGE): str,
         vol.Optional(ATTR_MEDIA): str,
@@ -77,25 +79,33 @@ def async_setup_services(hass: HomeAssistant) -> None:
         entry = async_get_entry(hass, call.data[ATTR_CONFIG_ENTRY_ID])
         client = entry.runtime_data.client
 
-        status = call.data[ATTR_STATUS]
+        status: str = call.data[ATTR_STATUS]
 
         visibility: str | None = (
             StatusVisibility(call.data[ATTR_VISIBILITY])
             if ATTR_VISIBILITY in call.data
             else None
         )
+        idempotency_key: str | None = call.data.get(ATTR_IDEMPOTENCY_KEY)
         spoiler_text: str | None = call.data.get(ATTR_CONTENT_WARNING)
         language: str | None = call.data.get(ATTR_LANGUAGE)
         media_path: str | None = call.data.get(ATTR_MEDIA)
         media_description: str | None = call.data.get(ATTR_MEDIA_DESCRIPTION)
         media_warning: str | None = call.data.get(ATTR_MEDIA_WARNING)
 
+        if idempotency_key and len(idempotency_key) < 4:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="idempotency_key_too_short",
+            )
+
         await hass.async_add_executor_job(
             partial(
                 _post,
                 client=client,
                 status=status,
                 visibility=visibility,
+                idempotency_key=idempotency_key,
                 spoiler_text=spoiler_text,
                 language=language,
                 media_path=media_path,

homeassistant/components/mastodon/services.yaml

@@ -18,6 +18,9 @@ post:
             - private
             - direct
           translation_key: post_visibility
+    idempotency_key:
+      selector:
+        text:
     content_warning:
       selector:
         text:

homeassistant/components/mastodon/strings.json

@@ -42,6 +42,9 @@
     }
   },
   "exceptions": {
+    "idempotency_key_too_short": {
+      "message": "Idempotency key must be at least 4 characters long."
+    },
     "integration_not_found": {
       "message": "Integration \"{target}\" not found in registry."
     },
@@ -80,6 +83,10 @@
           "description": "A content warning will be shown before the status text is shown (default: no content warning).",
           "name": "Content warning"
         },
+        "idempotency_key": {
+          "description": "A unique key for this post. If specified then subsequent posts with the same key will be ignored by your Mastodon instance. Mastodon holds keys for up to one hour (default: no idempotency key, which allows duplication).",
+          "name": "Idempotency key"
+        },
         "language": {
           "description": "The language of the post (default: Mastodon account preference).",
           "name": "Language"

homeassistant/components/matter/button.py

@@ -58,7 +58,7 @@ DISCOVERY_SCHEMAS = [
         platform=Platform.BUTTON,
         entity_description=MatterButtonEntityDescription(
             key="IdentifyButton",
-            entity_category=EntityCategory.CONFIG,
+            entity_category=EntityCategory.DIAGNOSTIC,
             device_class=ButtonDeviceClass.IDENTIFY,
             command=lambda: clusters.Identify.Commands.Identify(identifyTime=15),
         ),

homeassistant/components/meteo_france/const.py

@@ -87,7 +87,11 @@ CONDITION_CLASSES: dict[str, list[str]] = {
         "Averses de neige faible",
         "Quelques flocons",
     ],
-    ATTR_CONDITION_SNOWY_RAINY: ["Pluie et neige", "Pluie verglaçante"],
+    ATTR_CONDITION_SNOWY_RAINY: [
+        "Pluie et neige",
+        "Pluie verglaçante",
+        "Averses de pluie et neige",
+    ],
     ATTR_CONDITION_SUNNY: ["Ensoleillé"],
     ATTR_CONDITION_WINDY: [],
     ATTR_CONDITION_WINDY_VARIANT: [],