dry it up

Co-authored-by: mik-laj <12058428+mik-laj@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
@@ -389,6 +391,8 @@ build.json @home-assistant/supervisor
 /tests/components/dsmr/ @Robbie1221
 /homeassistant/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
 /tests/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
+/homeassistant/components/duckdns/ @tr4nt0r
+/tests/components/duckdns/ @tr4nt0r
 /homeassistant/components/duke_energy/ @hunterjm
 /tests/components/duke_energy/ @hunterjm
 /homeassistant/components/duotecno/ @cereal2nd
@@ -627,6 +631,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 +852,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/bang_olufsen/const.py

@@ -71,9 +71,26 @@ class BangOlufsenModel(StrEnum):
     BEOSOUND_BALANCE = "Beosound Balance"
     BEOSOUND_EMERGE = "Beosound Emerge"
     BEOSOUND_LEVEL = "Beosound Level"
+    BEOSOUND_PREMIERE = "Beosound Premiere"
     BEOSOUND_THEATRE = "Beosound Theatre"
 
 
+# Physical "buttons" on devices
+class BangOlufsenButtons(StrEnum):
+    """Enum for device buttons."""
+
+    BLUETOOTH = "Bluetooth"
+    MICROPHONE = "Microphone"
+    NEXT = "Next"
+    PLAY_PAUSE = "PlayPause"
+    PRESET_1 = "Preset1"
+    PRESET_2 = "Preset2"
+    PRESET_3 = "Preset3"
+    PRESET_4 = "Preset4"
+    PREVIOUS = "Previous"
+    VOLUME = "Volume"
+
+
 # Dispatcher events
 class WebsocketNotification(StrEnum):
     """Enum for WebSocket notification types."""
@@ -204,23 +221,6 @@ FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
         ),
     ]
 )
-# Map for storing compatibility of devices.
-
-MODEL_SUPPORT_DEVICE_BUTTONS: Final[str] = "device_buttons"
-
-MODEL_SUPPORT_MAP = {
-    MODEL_SUPPORT_DEVICE_BUTTONS: (
-        BangOlufsenModel.BEOLAB_8,
-        BangOlufsenModel.BEOLAB_28,
-        BangOlufsenModel.BEOSOUND_2,
-        BangOlufsenModel.BEOSOUND_A5,
-        BangOlufsenModel.BEOSOUND_A9,
-        BangOlufsenModel.BEOSOUND_BALANCE,
-        BangOlufsenModel.BEOSOUND_EMERGE,
-        BangOlufsenModel.BEOSOUND_LEVEL,
-        BangOlufsenModel.BEOSOUND_THEATRE,
-    )
-}
 
 # Device events
 BANG_OLUFSEN_WEBSOCKET_EVENT: Final[str] = f"{DOMAIN}_websocket_event"
@@ -236,18 +236,7 @@ EVENT_TRANSLATION_MAP: dict[str, str] = {
 
 CONNECTION_STATUS: Final[str] = "CONNECTION_STATUS"
 
-DEVICE_BUTTONS: Final[list[str]] = [
-    "Bluetooth",
-    "Microphone",
-    "Next",
-    "PlayPause",
-    "Preset1",
-    "Preset2",
-    "Preset3",
-    "Preset4",
-    "Previous",
-    "Volume",
-]
+DEVICE_BUTTONS: Final[list[str]] = [x.value for x in BangOlufsenButtons]
 
 
 DEVICE_BUTTON_EVENTS: Final[list[str]] = [

homeassistant/components/bang_olufsen/diagnostics.py

@@ -6,11 +6,13 @@ from typing import TYPE_CHECKING, Any
 
 from homeassistant.components.event import DOMAIN as EVENT_DOMAIN
 from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
 from . import BangOlufsenConfigEntry
-from .const import DEVICE_BUTTONS, DOMAIN
+from .const import DOMAIN
+from .util import get_device_buttons
 
 
 async def async_get_config_entry_diagnostics(
@@ -40,7 +42,7 @@ async def async_get_config_entry_diagnostics(
             data["media_player"] = state_dict
 
     # Add button Event entity states (if enabled)
-    for device_button in DEVICE_BUTTONS:
+    for device_button in get_device_buttons(config_entry.data[CONF_MODEL]):
         if entity_id := entity_registry.async_get_entity_id(
             EVENT_DOMAIN, DOMAIN, f"{config_entry.unique_id}_{device_button}"
         ):

homeassistant/components/bang_olufsen/event.py

@@ -9,15 +9,9 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BangOlufsenConfigEntry
-from .const import (
-    CONNECTION_STATUS,
-    DEVICE_BUTTON_EVENTS,
-    DEVICE_BUTTONS,
-    MODEL_SUPPORT_DEVICE_BUTTONS,
-    MODEL_SUPPORT_MAP,
-    WebsocketNotification,
-)
+from .const import CONNECTION_STATUS, DEVICE_BUTTON_EVENTS, WebsocketNotification
 from .entity import BangOlufsenEntity
+from .util import get_device_buttons
 
 PARALLEL_UPDATES = 0
 
@@ -29,11 +23,10 @@ async def async_setup_entry(
 ) -> None:
     """Set up Sensor entities from config entry."""
 
-    if config_entry.data[CONF_MODEL] in MODEL_SUPPORT_MAP[MODEL_SUPPORT_DEVICE_BUTTONS]:
-        async_add_entities(
-            BangOlufsenButtonEvent(config_entry, button_type)
-            for button_type in DEVICE_BUTTONS
-        )
+    async_add_entities(
+        BangOlufsenButtonEvent(config_entry, button_type)
+        for button_type in get_device_buttons(config_entry.data[CONF_MODEL])
+    )
 
 
 class BangOlufsenButtonEvent(BangOlufsenEntity, EventEntity):

homeassistant/components/bang_olufsen/util.py

@@ -6,7 +6,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceEntry
 
-from .const import DOMAIN
+from .const import DEVICE_BUTTONS, DOMAIN, BangOlufsenButtons, BangOlufsenModel
 
 
 def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
@@ -21,3 +21,18 @@ def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
 def get_serial_number_from_jid(jid: str) -> str:
     """Get serial number from Beolink JID."""
     return jid.split(".")[2].split("@")[0]
+
+
+def get_device_buttons(model: BangOlufsenModel) -> list[str]:
+    """Get supported buttons for a given model."""
+    buttons = DEVICE_BUTTONS.copy()
+
+    # Beosound Premiere does not have a bluetooth button
+    if model == BangOlufsenModel.BEOSOUND_PREMIERE:
+        buttons.remove(BangOlufsenButtons.BLUETOOTH)
+
+    # Beoconnect Core does not have any buttons
+    elif model == BangOlufsenModel.BEOCONNECT_CORE:
+        buttons = []
+
+    return buttons

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/duckdns/__init__.py

@@ -10,6 +10,7 @@ from typing import Any, cast
 from aiohttp import ClientSession
 import voluptuous as vol
 
+from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
 from homeassistant.core import (
     CALLBACK_TYPE,
@@ -18,13 +19,17 @@ from homeassistant.core import (
     ServiceCall,
     callback,
 )
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.event import async_call_later
+from homeassistant.helpers.selector import ConfigEntrySelector
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 from homeassistant.util import dt as dt_util
 
+from .const import ATTR_CONFIG_ENTRY
+
 _LOGGER = logging.getLogger(__name__)
 
 ATTR_TXT = "txt"
@@ -32,7 +37,13 @@ ATTR_TXT = "txt"
 DOMAIN = "duckdns"
 
 INTERVAL = timedelta(minutes=5)
-
+BACKOFF_INTERVALS = (
+    INTERVAL,
+    timedelta(minutes=1),
+    timedelta(minutes=5),
+    timedelta(minutes=15),
+    timedelta(minutes=30),
+)
 SERVICE_SET_TXT = "set_txt"
 
 UPDATE_URL = "https://www.duckdns.org/update"
@@ -49,39 +60,112 @@ CONFIG_SCHEMA = vol.Schema(
     extra=vol.ALLOW_EXTRA,
 )
 
-SERVICE_TXT_SCHEMA = vol.Schema({vol.Required(ATTR_TXT): vol.Any(None, cv.string)})
+SERVICE_TXT_SCHEMA = vol.Schema(
+    {
+        vol.Optional(ATTR_CONFIG_ENTRY): ConfigEntrySelector(
+            {
+                "integration": DOMAIN,
+            }
+        ),
+        vol.Optional(ATTR_TXT): vol.Any(None, cv.string),
+    }
+)
+
+type DuckDnsConfigEntry = ConfigEntry
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Initialize the DuckDNS component."""
-    domain: str = config[DOMAIN][CONF_DOMAIN]
-    token: str = config[DOMAIN][CONF_ACCESS_TOKEN]
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_SET_TXT,
+        update_domain_service,
+        schema=SERVICE_TXT_SCHEMA,
+    )
+
+    if DOMAIN not in config:
+        return True
+
+    hass.async_create_task(
+        hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": SOURCE_IMPORT}, data=config[DOMAIN]
+        )
+    )
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> bool:
+    """Set up Duck DNS from a config entry."""
+
     session = async_get_clientsession(hass)
 
     async def update_domain_interval(_now: datetime) -> bool:
         """Update the DuckDNS entry."""
-        return await _update_duckdns(session, domain, token)
+        return await _update_duckdns(
+            session,
+            entry.data[CONF_DOMAIN],
+            entry.data[CONF_ACCESS_TOKEN],
+        )
 
-    intervals = (
-        INTERVAL,
-        timedelta(minutes=1),
-        timedelta(minutes=5),
-        timedelta(minutes=15),
-        timedelta(minutes=30),
-    )
-    async_track_time_interval_backoff(hass, update_domain_interval, intervals)
-
-    async def update_domain_service(call: ServiceCall) -> None:
-        """Update the DuckDNS entry."""
-        await _update_duckdns(session, domain, token, txt=call.data[ATTR_TXT])
-
-    hass.services.async_register(
-        DOMAIN, SERVICE_SET_TXT, update_domain_service, schema=SERVICE_TXT_SCHEMA
+    entry.async_on_unload(
+        async_track_time_interval_backoff(
+            hass, update_domain_interval, BACKOFF_INTERVALS
+        )
     )
 
     return True
 
 
+def get_config_entry(
+    hass: HomeAssistant, entry_id: str | None = None
+) -> DuckDnsConfigEntry:
+    """Return config entry or raise if not found or not loaded."""
+
+    if entry_id is None:
+        if not (config_entries := hass.config_entries.async_entries(DOMAIN)):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="entry_not_found",
+            )
+
+        if len(config_entries) != 1:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="entry_not_selected",
+            )
+        return config_entries[0]
+
+    if not (entry := hass.config_entries.async_get_entry(entry_id)):
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="entry_not_found",
+        )
+
+    return entry
+
+
+async def update_domain_service(call: ServiceCall) -> None:
+    """Update the DuckDNS entry."""
+
+    entry = get_config_entry(call.hass, call.data.get(ATTR_CONFIG_ENTRY))
+
+    session = async_get_clientsession(call.hass)
+
+    await _update_duckdns(
+        session,
+        entry.data[CONF_DOMAIN],
+        entry.data[CONF_ACCESS_TOKEN],
+        txt=call.data.get(ATTR_TXT),
+    )
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: DuckDnsConfigEntry) -> bool:
+    """Unload a config entry."""
+    return True
+
+
 _SENTINEL = object()
 
 

homeassistant/components/duckdns/config_flow.py

@@ -0,0 +1,81 @@
+"""Config flow for the Duck DNS integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_DOMAIN
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
+
+from . import _update_duckdns
+from .const import DOMAIN
+from .issue import deprecate_yaml_issue
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_DOMAIN): TextSelector(
+            TextSelectorConfig(type=TextSelectorType.TEXT, suffix=".duckdns.org")
+        ),
+        vol.Required(CONF_ACCESS_TOKEN): str,
+    }
+)
+
+
+class DuckDnsConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Duck DNS."""
+
+    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:
+            self._async_abort_entries_match({CONF_DOMAIN: user_input[CONF_DOMAIN]})
+            session = async_get_clientsession(self.hass)
+            try:
+                if not await _update_duckdns(
+                    session,
+                    user_input[CONF_DOMAIN],
+                    user_input[CONF_ACCESS_TOKEN],
+                ):
+                    errors["base"] = "update_failed"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+            if not errors:
+                return self.async_create_entry(
+                    title=f"{user_input[CONF_DOMAIN]}.duckdns.org", data=user_input
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                data_schema=STEP_USER_DATA_SCHEMA, suggested_values=user_input
+            ),
+            errors=errors,
+            description_placeholders={"url": "https://www.duckdns.org/"},
+        )
+
+    async def async_step_import(self, import_info: dict[str, Any]) -> ConfigFlowResult:
+        """Import config from yaml."""
+
+        self._async_abort_entries_match({CONF_DOMAIN: import_info[CONF_DOMAIN]})
+        result = await self.async_step_user(import_info)
+        if errors := result.get("errors"):
+            deprecate_yaml_issue(self.hass, import_success=False)
+            return self.async_abort(reason=errors["base"])
+
+        deprecate_yaml_issue(self.hass, import_success=True)
+        return result

homeassistant/components/duckdns/const.py

@@ -0,0 +1,7 @@
+"""Constants for the Duck DNS integration."""
+
+from typing import Final
+
+DOMAIN = "duckdns"
+
+ATTR_CONFIG_ENTRY: Final = "config_entry_id"

homeassistant/components/duckdns/issue.py

@@ -0,0 +1,40 @@
+"""Issues for Duck DNS integration."""
+
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+
+from .const import DOMAIN
+
+
+@callback
+def deprecate_yaml_issue(hass: HomeAssistant, *, import_success: bool) -> None:
+    """Deprecate yaml issue."""
+    if import_success:
+        async_create_issue(
+            hass,
+            HOMEASSISTANT_DOMAIN,
+            f"deprecated_yaml_{DOMAIN}",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            breaks_in_ha_version="2026.6.0",
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_yaml",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": "Duck DNS",
+            },
+        )
+    else:
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "deprecated_yaml_import_issue_error",
+            breaks_in_ha_version="2026.6.0",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_yaml_import_issue_error",
+            translation_placeholders={
+                "url": "/config/integrations/dashboard/add?domain=duckdns"
+            },
+        )

homeassistant/components/duckdns/manifest.json

@@ -1,8 +1,8 @@
 {
   "domain": "duckdns",
   "name": "Duck DNS",
-  "codeowners": [],
+  "codeowners": ["@tr4nt0r"],
+  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/duckdns",
-  "iot_class": "cloud_polling",
-  "quality_scale": "legacy"
+  "iot_class": "cloud_polling"
 }

homeassistant/components/duckdns/services.yaml

@@ -1,7 +1,10 @@
 set_txt:
   fields:
+    config_entry_id:
+      selector:
+        config_entry:
+          integration: duckdns
     txt:
-      required: true
       example: "This domain name is reserved for use in documentation"
       selector:
         text:

homeassistant/components/duckdns/strings.json

@@ -1,8 +1,48 @@
 {
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "unknown": "[%key:common::config_flow::error::unknown%]",
+      "update_failed": "Updating Duck DNS failed"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "access_token": "Token",
+          "domain": "Subdomain"
+        },
+        "data_description": {
+          "access_token": "Your Duck DNS account token",
+          "domain": "The Duck DNS subdomain to update"
+        },
+        "description": "Enter your Duck DNS subdomain and token below to configure dynamic DNS updates. You can find your token on the [Duck DNS]({url}) homepage after logging into your account."
+      }
+    }
+  },
+  "exceptions": {
+    "entry_not_found": {
+      "message": "Duck DNS integration entry not found"
+    },
+    "entry_not_selected": {
+      "message": "Duck DNS integration entry not selected"
+    }
+  },
+  "issues": {
+    "deprecated_yaml_import_issue_error": {
+      "description": "Configuring Duck DNS using YAML is being removed but there was an error when trying to import the YAML configuration.\n\nEnsure the YAML configuration is correct and restart Home Assistant to try again or remove the Duck DNS YAML configuration from your `configuration.yaml` file and continue to [set up the integration]({url}) manually.",
+      "title": "The Duck DNS YAML configuration import failed"
+    }
+  },
   "services": {
     "set_txt": {
-      "description": "Sets the TXT record of your DuckDNS subdomain.",
+      "description": "Sets the TXT record of your Duck DNS subdomain.",
       "fields": {
+        "config_entry_id": {
+          "description": "The Duck DNS integration ID.",
+          "name": "Integration ID"
+        },
         "txt": {
           "description": "Payload for the TXT record.",
           "name": "TXT"

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/google_weather/__init__.py

@@ -20,7 +20,7 @@ from .coordinator import (
     GoogleWeatherSubEntryRuntimeData,
 )
 
-_PLATFORMS: list[Platform] = [Platform.WEATHER]
+_PLATFORMS: list[Platform] = [Platform.SENSOR, Platform.WEATHER]
 
 
 async def async_setup_entry(

homeassistant/components/google_weather/entity.py

@@ -16,10 +16,15 @@ class GoogleWeatherBaseEntity(Entity):
     _attr_has_entity_name = True
 
     def __init__(
-        self, config_entry: GoogleWeatherConfigEntry, subentry: ConfigSubentry
+        self,
+        config_entry: GoogleWeatherConfigEntry,
+        subentry: ConfigSubentry,
+        unique_id_suffix: str | None = None,
     ) -> None:
         """Initialize base entity."""
         self._attr_unique_id = subentry.subentry_id
+        if unique_id_suffix is not None:
+            self._attr_unique_id += f"_{unique_id_suffix.lower()}"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, subentry.subentry_id)},
             name=subentry.title,

homeassistant/components/google_weather/icons.json

@@ -0,0 +1,27 @@
+{
+  "entity": {
+    "sensor": {
+      "cloud_coverage": {
+        "default": "mdi:weather-cloudy"
+      },
+      "precipitation_probability": {
+        "default": "mdi:weather-rainy"
+      },
+      "precipitation_qpf": {
+        "default": "mdi:cup-water"
+      },
+      "thunderstorm_probability": {
+        "default": "mdi:weather-lightning"
+      },
+      "uv_index": {
+        "default": "mdi:weather-sunny-alert"
+      },
+      "visibility": {
+        "default": "mdi:eye"
+      },
+      "weather_condition": {
+        "default": "mdi:card-text-outline"
+      }
+    }
+  }
+}

homeassistant/components/google_weather/sensor.py

@@ -0,0 +1,233 @@
+"""Support for Google Weather sensors."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from google_weather_api import CurrentConditionsResponse
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.config_entries import ConfigSubentry
+from homeassistant.const import (
+    DEGREE,
+    PERCENTAGE,
+    UV_INDEX,
+    UnitOfLength,
+    UnitOfPressure,
+    UnitOfSpeed,
+    UnitOfTemperature,
+    UnitOfVolumetricFlux,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .coordinator import (
+    GoogleWeatherConfigEntry,
+    GoogleWeatherCurrentConditionsCoordinator,
+)
+from .entity import GoogleWeatherBaseEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class GoogleWeatherSensorDescription(SensorEntityDescription):
+    """Class describing Google Weather sensor entities."""
+
+    value_fn: Callable[[CurrentConditionsResponse], str | int | float | None]
+
+
+SENSOR_TYPES: tuple[GoogleWeatherSensorDescription, ...] = (
+    GoogleWeatherSensorDescription(
+        key="temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda data: data.temperature.degrees,
+    ),
+    GoogleWeatherSensorDescription(
+        key="feelsLikeTemperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda data: data.feels_like_temperature.degrees,
+        translation_key="apparent_temperature",
+    ),
+    GoogleWeatherSensorDescription(
+        key="dewPoint",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda data: data.dew_point.degrees,
+        translation_key="dew_point",
+    ),
+    GoogleWeatherSensorDescription(
+        key="heatIndex",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda data: data.heat_index.degrees,
+        translation_key="heat_index",
+    ),
+    GoogleWeatherSensorDescription(
+        key="windChill",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        value_fn=lambda data: data.wind_chill.degrees,
+        translation_key="wind_chill",
+    ),
+    GoogleWeatherSensorDescription(
+        key="relativeHumidity",
+        device_class=SensorDeviceClass.HUMIDITY,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+        value_fn=lambda data: data.relative_humidity,
+    ),
+    GoogleWeatherSensorDescription(
+        key="uvIndex",
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UV_INDEX,
+        value_fn=lambda data: data.uv_index,
+        translation_key="uv_index",
+    ),
+    GoogleWeatherSensorDescription(
+        key="precipitation_probability",
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+        value_fn=lambda data: data.precipitation.probability.percent,
+        translation_key="precipitation_probability",
+    ),
+    GoogleWeatherSensorDescription(
+        key="precipitation_qpf",
+        device_class=SensorDeviceClass.PRECIPITATION_INTENSITY,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
+        value_fn=lambda data: data.precipitation.qpf.quantity,
+    ),
+    GoogleWeatherSensorDescription(
+        key="thunderstormProbability",
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+        value_fn=lambda data: data.thunderstorm_probability,
+        translation_key="thunderstorm_probability",
+    ),
+    GoogleWeatherSensorDescription(
+        key="airPressure",
+        device_class=SensorDeviceClass.ATMOSPHERIC_PRESSURE,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+        native_unit_of_measurement=UnitOfPressure.HPA,
+        value_fn=lambda data: data.air_pressure.mean_sea_level_millibars,
+    ),
+    GoogleWeatherSensorDescription(
+        key="wind_direction",
+        device_class=SensorDeviceClass.WIND_DIRECTION,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT_ANGLE,
+        native_unit_of_measurement=DEGREE,
+        value_fn=lambda data: data.wind.direction.degrees,
+    ),
+    GoogleWeatherSensorDescription(
+        key="wind_speed",
+        device_class=SensorDeviceClass.WIND_SPEED,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfSpeed.KILOMETERS_PER_HOUR,
+        value_fn=lambda data: data.wind.speed.value,
+    ),
+    GoogleWeatherSensorDescription(
+        key="wind_gust",
+        device_class=SensorDeviceClass.WIND_SPEED,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfSpeed.KILOMETERS_PER_HOUR,
+        value_fn=lambda data: data.wind.gust.value,
+        translation_key="wind_gust_speed",
+    ),
+    GoogleWeatherSensorDescription(
+        key="visibility",
+        device_class=SensorDeviceClass.DISTANCE,
+        entity_registry_enabled_default=False,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfLength.KILOMETERS,
+        value_fn=lambda data: data.visibility.distance,
+        translation_key="visibility",
+    ),
+    GoogleWeatherSensorDescription(
+        key="cloudCover",
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+        value_fn=lambda data: data.cloud_cover,
+        translation_key="cloud_coverage",
+    ),
+    GoogleWeatherSensorDescription(
+        key="weatherCondition",
+        entity_registry_enabled_default=False,
+        value_fn=lambda data: data.weather_condition.description.text,
+        translation_key="weather_condition",
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: GoogleWeatherConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add Google Weather entities from a config_entry."""
+    for subentry in entry.subentries.values():
+        subentry_runtime_data = entry.runtime_data.subentries_runtime_data[
+            subentry.subentry_id
+        ]
+        coordinator = subentry_runtime_data.coordinator_observation
+        async_add_entities(
+            (
+                GoogleWeatherSensor(coordinator, subentry, description)
+                for description in SENSOR_TYPES
+                if description.value_fn(coordinator.data) is not None
+            ),
+            config_subentry_id=subentry.subentry_id,
+        )
+
+
+class GoogleWeatherSensor(
+    CoordinatorEntity[GoogleWeatherCurrentConditionsCoordinator],
+    GoogleWeatherBaseEntity,
+    SensorEntity,
+):
+    """Define a Google Weather entity."""
+
+    entity_description: GoogleWeatherSensorDescription
+
+    def __init__(
+        self,
+        coordinator: GoogleWeatherCurrentConditionsCoordinator,
+        subentry: ConfigSubentry,
+        description: GoogleWeatherSensorDescription,
+    ) -> None:
+        """Initialize."""
+        super().__init__(coordinator)
+        GoogleWeatherBaseEntity.__init__(
+            self, coordinator.config_entry, subentry, description.key
+        )
+        self.entity_description = description
+
+    @property
+    def native_value(self) -> str | int | float | None:
+        """Return the state."""
+        return self.entity_description.value_fn(self.coordinator.data)

homeassistant/components/google_weather/strings.json

@@ -61,5 +61,42 @@
         }
       }
     }
+  },
+  "entity": {
+    "sensor": {
+      "apparent_temperature": {
+        "name": "Apparent temperature"
+      },
+      "cloud_coverage": {
+        "name": "Cloud coverage"
+      },
+      "dew_point": {
+        "name": "Dew point"
+      },
+      "heat_index": {
+        "name": "Heat index temperature"
+      },
+      "precipitation_probability": {
+        "name": "Precipitation probability"
+      },
+      "thunderstorm_probability": {
+        "name": "Thunderstorm probability"
+      },
+      "uv_index": {
+        "name": "UV index"
+      },
+      "visibility": {
+        "name": "Visibility"
+      },
+      "weather_condition": {
+        "name": "Weather condition"
+      },
+      "wind_chill": {
+        "name": "Wind chill temperature"
+      },
+      "wind_gust_speed": {
+        "name": "Wind gust speed"
+      }
+    }
   }
 }

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/hassio/const.py

@@ -128,6 +128,8 @@ ISSUE_KEY_ADDON_PWNED = "issue_addon_pwned"
 ISSUE_KEY_SYSTEM_FREE_SPACE = "issue_system_free_space"
 ISSUE_KEY_ADDON_DEPRECATED = "issue_addon_deprecated_addon"
 
+ISSUE_MOUNT_MOUNT_FAILED = "issue_mount_mount_failed"
+
 CORE_CONTAINER = "homeassistant"
 SUPERVISOR_CONTAINER = "hassio_supervisor"
 

homeassistant/components/hassio/issues.py

@@ -27,6 +27,7 @@ from homeassistant.helpers.issue_registry import (
 )
 
 from .const import (
+    ADDONS_COORDINATOR,
     ATTR_DATA,
     ATTR_HEALTHY,
     ATTR_STARTUP,
@@ -49,6 +50,7 @@ from .const import (
     ISSUE_KEY_ADDON_PWNED,
     ISSUE_KEY_SYSTEM_DOCKER_CONFIG,
     ISSUE_KEY_SYSTEM_FREE_SPACE,
+    ISSUE_MOUNT_MOUNT_FAILED,
     PLACEHOLDER_KEY_ADDON,
     PLACEHOLDER_KEY_ADDON_URL,
     PLACEHOLDER_KEY_FREE_SPACE,
@@ -57,7 +59,7 @@ from .const import (
     STARTUP_COMPLETE,
     UPDATE_KEY_SUPERVISOR,
 )
-from .coordinator import get_addons_info, get_host_info
+from .coordinator import HassioDataUpdateCoordinator, get_addons_info, get_host_info
 from .handler import HassIO, get_supervisor_client
 
 ISSUE_KEY_UNHEALTHY = "unhealthy"
@@ -77,7 +79,7 @@ UNSUPPORTED_SKIP_REPAIR = {"privileged"}
 # Keys (type + context) of issues that when found should be made into a repair
 ISSUE_KEYS_FOR_REPAIRS = {
     ISSUE_KEY_ADDON_BOOT_FAIL,
-    "issue_mount_mount_failed",
+    ISSUE_MOUNT_MOUNT_FAILED,
     "issue_system_multiple_data_disks",
     "issue_system_reboot_required",
     ISSUE_KEY_SYSTEM_DOCKER_CONFIG,
@@ -284,6 +286,9 @@ class SupervisorIssues:
                 else:
                     placeholders[PLACEHOLDER_KEY_FREE_SPACE] = "<2"
 
+            if issue.key == ISSUE_MOUNT_MOUNT_FAILED:
+                self._async_coordinator_refresh()
+
             async_create_issue(
                 self._hass,
                 DOMAIN,
@@ -336,6 +341,9 @@ class SupervisorIssues:
         if issue.key in ISSUE_KEYS_FOR_REPAIRS:
             async_delete_issue(self._hass, DOMAIN, issue.uuid.hex)
 
+            if issue.key == ISSUE_MOUNT_MOUNT_FAILED:
+                self._async_coordinator_refresh()
+
         del self._issues[issue.uuid]
 
     def get_issue(self, issue_id: str) -> Issue | None:
@@ -406,3 +414,11 @@ class SupervisorIssues:
 
         elif event[ATTR_WS_EVENT] == EVENT_ISSUE_REMOVED:
             self.remove_issue(Issue.from_dict(event[ATTR_DATA]))
+
+    def _async_coordinator_refresh(self) -> None:
+        """Refresh coordinator to update latest data in entities."""
+        coordinator: HassioDataUpdateCoordinator | None
+        if coordinator := self._hass.data.get(ADDONS_COORDINATOR):
+            coordinator.config_entry.async_create_task(
+                self._hass, coordinator.async_refresh()
+            )

homeassistant/components/home_connect/const.py

@@ -13,11 +13,13 @@ DOMAIN = "home_connect"
 API_DEFAULT_RETRY_AFTER = 60
 
 APPLIANCES_WITH_PROGRAMS = (
+    "AirConditioner",
     "CleaningRobot",
     "CoffeeMaker",
     "Dishwasher",
     "Dryer",
     "Hood",
+    "Microwave",
     "Oven",
     "WarmingDrawer",
     "Washer",
@@ -83,6 +85,14 @@ PROGRAMS_TRANSLATION_KEYS_MAP = {
     value: key for key, value in TRANSLATION_KEYS_PROGRAMS_MAP.items()
 }
 
+FAN_SPEED_MODE_OPTIONS = {
+    bsh_key_to_translation_key(option): option
+    for option in (
+        "HeatingVentilationAirConditioning.AirConditioner.EnumType.FanSpeedMode.Automatic",
+        "HeatingVentilationAirConditioning.AirConditioner.EnumType.FanSpeedMode.Manual",
+    )
+}
+
 AVAILABLE_MAPS_ENUM = {
     bsh_key_to_translation_key(option): option
     for option in (
@@ -315,6 +325,10 @@ PROGRAM_ENUM_OPTIONS = {
         options,
     )
     for option_key, options in (
+        (
+            OptionKey.HEATING_VENTILATION_AIR_CONDITIONING_AIR_CONDITIONER_FAN_SPEED_MODE,
+            FAN_SPEED_MODE_OPTIONS,
+        ),
         (
             OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_REFERENCE_MAP_ID,
             AVAILABLE_MAPS_ENUM,

homeassistant/components/home_connect/services.yaml

@@ -82,6 +82,12 @@ set_program_and_options:
             - dishcare_dishwasher_program_maximum_cleaning
             - dishcare_dishwasher_program_mixed_load
             - dishcare_dishwasher_program_learning_dishwasher
+            - heating_ventilation_air_conditioning_air_conditioner_program_active_clean
+            - heating_ventilation_air_conditioning_air_conditioner_program_auto
+            - heating_ventilation_air_conditioning_air_conditioner_program_cool
+            - heating_ventilation_air_conditioning_air_conditioner_program_dry
+            - heating_ventilation_air_conditioning_air_conditioner_program_fan
+            - heating_ventilation_air_conditioning_air_conditioner_program_heat
             - laundry_care_dryer_program_cotton
             - laundry_care_dryer_program_synthetic
             - laundry_care_dryer_program_mix
@@ -136,6 +142,7 @@ set_program_and_options:
             - cooking_oven_program_microwave_90_watt
             - cooking_oven_program_microwave_180_watt
             - cooking_oven_program_microwave_360_watt
+            - cooking_oven_program_microwave_450_watt
             - cooking_oven_program_microwave_600_watt
             - cooking_oven_program_microwave_900_watt
             - cooking_oven_program_microwave_1000_watt
@@ -177,6 +184,28 @@ set_program_and_options:
             - laundry_care_washer_dryer_program_easy_care
             - laundry_care_washer_dryer_program_wash_and_dry_60
             - laundry_care_washer_dryer_program_wash_and_dry_90
+    air_conditioner_options:
+      collapsed: true
+      fields:
+        heating_ventilation_air_conditioning_air_conditioner_option_fan_speed_percentage:
+          example: 50
+          required: false
+          selector:
+            number:
+              min: 1
+              max: 100
+              step: 1
+              mode: box
+              unit_of_measurement: "%"
+        heating_ventilation_air_conditioning_air_conditioner_option_fan_speed_mode:
+          required: false
+          selector:
+            select:
+              mode: dropdown
+              translation_key: fan_speed_mode
+              options:
+                - heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_automatic
+                - heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_manual
     cleaning_robot_options:
       collapsed: true
       fields:

homeassistant/components/home_connect/strings.json

@@ -252,6 +252,7 @@
           "cooking_oven_program_microwave_1000_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_1000_watt%]",
           "cooking_oven_program_microwave_180_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_180_watt%]",
           "cooking_oven_program_microwave_360_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_360_watt%]",
+          "cooking_oven_program_microwave_450_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_450_watt%]",
           "cooking_oven_program_microwave_600_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_600_watt%]",
           "cooking_oven_program_microwave_900_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_900_watt%]",
           "cooking_oven_program_microwave_90_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_90_watt%]",
@@ -281,6 +282,12 @@
           "dishcare_dishwasher_program_quick_65": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_quick_65%]",
           "dishcare_dishwasher_program_steam_fresh": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_steam_fresh%]",
           "dishcare_dishwasher_program_super_60": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_super_60%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_active_clean": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_active_clean%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_auto": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_auto%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_cool": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_cool%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_dry": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_dry%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_fan": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_fan%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_heat": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_heat%]",
           "laundry_care_dryer_program_anti_shrink": "[%key:component::home_connect::selector::programs::options::laundry_care_dryer_program_anti_shrink%]",
           "laundry_care_dryer_program_blankets": "[%key:component::home_connect::selector::programs::options::laundry_care_dryer_program_blankets%]",
           "laundry_care_dryer_program_business_shirts": "[%key:component::home_connect::selector::programs::options::laundry_care_dryer_program_business_shirts%]",
@@ -443,6 +450,13 @@
           "laundry_care_dryer_enum_type_drying_target_iron_dry": "[%key:component::home_connect::selector::drying_target::options::laundry_care_dryer_enum_type_drying_target_iron_dry%]"
         }
       },
+      "fan_speed_mode": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::heating_ventilation_air_conditioning_air_conditioner_option_fan_speed_mode::name%]",
+        "state": {
+          "heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_automatic": "[%key:component::home_connect::selector::fan_speed_mode::options::heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_automatic%]",
+          "heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_manual": "[%key:component::home_connect::selector::fan_speed_mode::options::heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_manual%]"
+        }
+      },
       "flow_rate": {
         "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_flow_rate::name%]",
         "state": {
@@ -575,6 +589,7 @@
           "cooking_oven_program_microwave_1000_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_1000_watt%]",
           "cooking_oven_program_microwave_180_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_180_watt%]",
           "cooking_oven_program_microwave_360_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_360_watt%]",
+          "cooking_oven_program_microwave_450_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_450_watt%]",
           "cooking_oven_program_microwave_600_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_600_watt%]",
           "cooking_oven_program_microwave_900_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_900_watt%]",
           "cooking_oven_program_microwave_90_watt": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_microwave_90_watt%]",
@@ -604,6 +619,12 @@
           "dishcare_dishwasher_program_quick_65": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_quick_65%]",
           "dishcare_dishwasher_program_steam_fresh": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_steam_fresh%]",
           "dishcare_dishwasher_program_super_60": "[%key:component::home_connect::selector::programs::options::dishcare_dishwasher_program_super_60%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_active_clean": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_active_clean%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_auto": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_auto%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_cool": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_cool%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_dry": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_dry%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_fan": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_fan%]",
+          "heating_ventilation_air_conditioning_air_conditioner_program_heat": "[%key:component::home_connect::selector::programs::options::heating_ventilation_air_conditioning_air_conditioner_program_heat%]",
           "laundry_care_dryer_program_anti_shrink": "[%key:component::home_connect::selector::programs::options::laundry_care_dryer_program_anti_shrink%]",
           "laundry_care_dryer_program_blankets": "[%key:component::home_connect::selector::programs::options::laundry_care_dryer_program_blankets%]",
           "laundry_care_dryer_program_business_shirts": "[%key:component::home_connect::selector::programs::options::laundry_care_dryer_program_business_shirts%]",
@@ -1418,6 +1439,12 @@
         "laundry_care_dryer_enum_type_drying_target_iron_dry": "Iron dry"
       }
     },
+    "fan_speed_mode": {
+      "options": {
+        "heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_automatic": "Auto",
+        "heating_ventilation_air_conditioning_air_conditioner_enum_type_fan_speed_mode_manual": "Manual"
+      }
+    },
     "flow_rate": {
       "options": {
         "consumer_products_coffee_maker_enum_type_flow_rate_intense": "Intense",
@@ -1526,6 +1553,7 @@
         "cooking_oven_program_microwave_1000_watt": "1000 Watt",
         "cooking_oven_program_microwave_180_watt": "180 Watt",
         "cooking_oven_program_microwave_360_watt": "360 Watt",
+        "cooking_oven_program_microwave_450_watt": "450 Watt",
         "cooking_oven_program_microwave_600_watt": "600 Watt",
         "cooking_oven_program_microwave_900_watt": "900 Watt",
         "cooking_oven_program_microwave_90_watt": "90 Watt",
@@ -1555,6 +1583,12 @@
         "dishcare_dishwasher_program_quick_65": "Quick 65ºC",
         "dishcare_dishwasher_program_steam_fresh": "Steam fresh",
         "dishcare_dishwasher_program_super_60": "Super 60ºC",
+        "heating_ventilation_air_conditioning_air_conditioner_program_active_clean": "Active clean",
+        "heating_ventilation_air_conditioning_air_conditioner_program_auto": "Auto",
+        "heating_ventilation_air_conditioning_air_conditioner_program_cool": "Cool",
+        "heating_ventilation_air_conditioning_air_conditioner_program_dry": "Dry",
+        "heating_ventilation_air_conditioning_air_conditioner_program_fan": "Fan",
+        "heating_ventilation_air_conditioning_air_conditioner_program_heat": "Heat",
         "laundry_care_dryer_program_anti_shrink": "Anti shrink",
         "laundry_care_dryer_program_blankets": "Blankets",
         "laundry_care_dryer_program_business_shirts": "Business shirts",
@@ -1823,6 +1857,14 @@
           "description": "Defines if the program sequence is optimized with special drying cycle ensures improved drying for glasses, plates and plasticware.",
           "name": "Zeolite dry"
         },
+        "heating_ventilation_air_conditioning_air_conditioner_option_fan_speed_mode": {
+          "description": "Setting to adjust the fan speed mode to Manual or Auto.",
+          "name": "Fan speed mode"
+        },
+        "heating_ventilation_air_conditioning_air_conditioner_option_fan_speed_percentage": {
+          "description": "Setting to adjust the venting level of the air conditioner as a percentage.",
+          "name": "Fan speed percentage"
+        },
         "laundry_care_dryer_option_drying_target": {
           "description": "Describes the drying target for a dryer program.",
           "name": "Drying target"
@@ -1854,6 +1896,10 @@
       },
       "name": "Set program and options",
       "sections": {
+        "air_conditioner_options": {
+          "description": "Specific settings for air conditioners.",
+          "name": "Air conditioner options"
+        },
         "cleaning_robot_options": {
           "description": "Options for cleaning robots.",
           "name": "Cleaning robot options"

homeassistant/components/homeassistant_connect_zbt2/strings.json

@@ -62,6 +62,10 @@
         },
         "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::pick_firmware::title%]"
       },
+      "show_z2m_docs_url": {
+        "description": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::description%]",
+        "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::title%]"
+      },
       "start_otbr_addon": {
         "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::start_otbr_addon::title%]"
       },
@@ -204,6 +208,10 @@
       "reconfigure_addon": {
         "title": "[%key:component::homeassistant_hardware::silabs_multiprotocol_hardware::options::step::reconfigure_addon::title%]"
       },
+      "show_z2m_docs_url": {
+        "description": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::description%]",
+        "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::title%]"
+      },
       "start_addon": {
         "title": "[%key:component::homeassistant_hardware::silabs_multiprotocol_hardware::options::step::start_addon::title%]"
       },

homeassistant/components/homeassistant_hardware/const.py

@@ -35,3 +35,5 @@ ZIGBEE_FLASHER_ADDON_SLUG = "core_silabs_flasher"
 
 SILABS_MULTIPROTOCOL_ADDON_SLUG = "core_silabs_multiprotocol"
 SILABS_FLASHER_ADDON_SLUG = "core_silabs_flasher"
+
+Z2M_EMBER_DOCS_URL = "https://www.zigbee2mqtt.io/guide/adapters/emberznet.html"

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -33,7 +33,7 @@ from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.hassio import is_hassio
 
-from .const import OTBR_DOMAIN, ZHA_DOMAIN
+from .const import OTBR_DOMAIN, Z2M_EMBER_DOCS_URL, ZHA_DOMAIN
 from .util import (
     ApplicationType,
     FirmwareInfo,
@@ -456,7 +456,7 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         assert self._hardware_name is not None
 
         if self._zigbee_integration == ZigbeeIntegration.OTHER:
-            return self._async_flow_finished()
+            return await self.async_step_show_z2m_docs_url()
 
         result = await self.hass.config_entries.flow.async_init(
             ZHA_DOMAIN,
@@ -475,6 +475,21 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         )
         return self._continue_zha_flow(result)
 
+    async def async_step_show_z2m_docs_url(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Show Zigbee2MQTT documentation link."""
+        if user_input is not None:
+            return self._async_flow_finished()
+
+        return self.async_show_form(
+            step_id="show_z2m_docs_url",
+            description_placeholders={
+                **self._get_translation_placeholders(),
+                "z2m_docs_url": Z2M_EMBER_DOCS_URL,
+            },
+        )
+
     @callback
     def _continue_zha_flow(self, zha_result: ConfigFlowResult) -> ConfigFlowResult:
         """Continue the ZHA flow."""

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/homeassistant_hardware/strings.json

@@ -53,6 +53,10 @@
           },
           "title": "Pick your protocol"
         },
+        "show_z2m_docs_url": {
+          "description": "Your {model} is now running the latest Zigbee firmware.\nPlease read the Zigbee2MQTT documentation for EmberZNet adapters and copy the config for your {model}: {z2m_docs_url}",
+          "title": "Set up Zigbee2MQTT"
+        },
         "start_otbr_addon": {
           "title": "Configuring Thread"
         },

homeassistant/components/homeassistant_sky_connect/strings.json

@@ -62,6 +62,10 @@
         },
         "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::pick_firmware::title%]"
       },
+      "show_z2m_docs_url": {
+        "description": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::description%]",
+        "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::title%]"
+      },
       "start_otbr_addon": {
         "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::start_otbr_addon::title%]"
       },
@@ -204,6 +208,10 @@
       "reconfigure_addon": {
         "title": "[%key:component::homeassistant_hardware::silabs_multiprotocol_hardware::options::step::reconfigure_addon::title%]"
       },
+      "show_z2m_docs_url": {
+        "description": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::description%]",
+        "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::title%]"
+      },
       "start_addon": {
         "title": "[%key:component::homeassistant_hardware::silabs_multiprotocol_hardware::options::step::start_addon::title%]"
       },

homeassistant/components/homeassistant_yellow/strings.json

@@ -138,6 +138,10 @@
       "reconfigure_addon": {
         "title": "[%key:component::homeassistant_hardware::silabs_multiprotocol_hardware::options::step::reconfigure_addon::title%]"
       },
+      "show_z2m_docs_url": {
+        "description": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::description%]",
+        "title": "[%key:component::homeassistant_hardware::firmware_picker::options::step::show_z2m_docs_url::title%]"
+      },
       "start_addon": {
         "title": "[%key:component::homeassistant_hardware::silabs_multiprotocol_hardware::options::step::start_addon::title%]"
       },

homeassistant/components/homematicip_cloud/binary_sensor.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any
 
 from homematicip.base.enums import SmokeDetectorAlarmType, WindowState
+from homematicip.base.functionalChannels import MultiModeInputChannel
 from homematicip.device import (
     AccelerationSensor,
     ContactInterface,
@@ -87,8 +88,11 @@ async def async_setup_entry(
             entities.append(HomematicipTiltVibrationSensor(hap, device))
         if isinstance(device, WiredInput32):
             entities.extend(
-                HomematicipMultiContactInterface(hap, device, channel=channel)
-                for channel in range(1, 33)
+                HomematicipMultiContactInterface(
+                    hap, device, channel_real_index=channel.index
+                )
+                for channel in device.functionalChannels
+                if isinstance(channel, MultiModeInputChannel)
             )
         elif isinstance(device, FullFlushContactInterface6):
             entities.extend(
@@ -227,21 +231,24 @@ class HomematicipMultiContactInterface(HomematicipGenericEntity, BinarySensorEnt
         device,
         channel=1,
         is_multi_channel=True,
+        channel_real_index=None,
     ) -> None:
         """Initialize the multi contact entity."""
         super().__init__(
-            hap, device, channel=channel, is_multi_channel=is_multi_channel
+            hap,
+            device,
+            channel=channel,
+            is_multi_channel=is_multi_channel,
+            channel_real_index=channel_real_index,
         )
 
     @property
     def is_on(self) -> bool | None:
         """Return true if the contact interface is on/open."""
-        if self._device.functionalChannels[self._channel].windowState is None:
+        channel = self.get_channel_or_raise()
+        if channel.windowState is None:
             return None
-        return (
-            self._device.functionalChannels[self._channel].windowState
-            != WindowState.CLOSED
-        )
+        return channel.windowState != WindowState.CLOSED
 
 
 class HomematicipContactInterface(HomematicipMultiContactInterface, BinarySensorEntity):

homeassistant/components/homematicip_cloud/cover.py

@@ -283,19 +283,23 @@ class HomematicipGarageDoorModule(HomematicipGenericEntity, CoverEntity):
     @property
     def is_closed(self) -> bool | None:
         """Return if the cover is closed."""
-        return self.functional_channel.doorState == DoorState.CLOSED
+        channel = self.get_channel_or_raise()
+        return channel.doorState == DoorState.CLOSED
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Open the cover."""
-        await self.functional_channel.async_send_door_command(DoorCommand.OPEN)
+        channel = self.get_channel_or_raise()
+        await channel.async_send_door_command(DoorCommand.OPEN)
 
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover."""
-        await self.functional_channel.async_send_door_command(DoorCommand.CLOSE)
+        channel = self.get_channel_or_raise()
+        await channel.async_send_door_command(DoorCommand.CLOSE)
 
     async def async_stop_cover(self, **kwargs: Any) -> None:
         """Stop the cover."""
-        await self.functional_channel.async_send_door_command(DoorCommand.STOP)
+        channel = self.get_channel_or_raise()
+        await channel.async_send_door_command(DoorCommand.STOP)
 
 
 class HomematicipCoverShutterGroup(HomematicipGenericEntity, CoverEntity):

homeassistant/components/homematicip_cloud/entity.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import contextlib
 import logging
 from typing import Any
 
@@ -84,6 +85,7 @@ class HomematicipGenericEntity(Entity):
         post: str | None = None,
         channel: int | None = None,
         is_multi_channel: bool | None = False,
+        channel_real_index: int | None = None,
     ) -> None:
         """Initialize the generic entity."""
         self._hap = hap
@@ -91,8 +93,19 @@ class HomematicipGenericEntity(Entity):
         self._device = device
         self._post = post
         self._channel = channel
+
+        # channel_real_index represents the actual index of the devices channel.
+        # Accessing a functionalChannel by the channel parameter or array index is unreliable,
+        # because the functionalChannels array is sorted as strings, not numbers.
+        # For example, channels are ordered as: 1, 10, 11, 12, 2, 3, ...
+        # Using channel_real_index ensures you reference the correct channel.
+        self._channel_real_index: int | None = channel_real_index
+
         self._is_multi_channel = is_multi_channel
-        self.functional_channel = self.get_current_channel()
+        self.functional_channel = None
+        with contextlib.suppress(ValueError):
+            self.functional_channel = self.get_current_channel()
+
         # Marker showing that the HmIP device hase been removed.
         self.hmip_device_removed = False
 
@@ -101,17 +114,20 @@ class HomematicipGenericEntity(Entity):
         """Return device specific attributes."""
         # Only physical devices should be HA devices.
         if isinstance(self._device, Device):
+            device_id = str(self._device.id)
+            home_id = str(self._device.homeId)
+
             return DeviceInfo(
                 identifiers={
                     # Serial numbers of Homematic IP device
-                    (DOMAIN, self._device.id)
+                    (DOMAIN, device_id)
                 },
                 manufacturer=self._device.oem,
                 model=self._device.modelType,
                 name=self._device.label,
                 sw_version=self._device.firmwareVersion,
                 # Link to the homematic ip access point.
-                via_device=(DOMAIN, self._device.homeId),
+                via_device=(DOMAIN, home_id),
             )
         return None
 
@@ -185,25 +201,31 @@ class HomematicipGenericEntity(Entity):
     def name(self) -> str:
         """Return the name of the generic entity."""
 
-        name = None
+        name = ""
         # Try to get a label from a channel.
-        if hasattr(self._device, "functionalChannels"):
+        functional_channels = getattr(self._device, "functionalChannels", None)
+        if functional_channels and self.functional_channel:
             if self._is_multi_channel:
-                name = self._device.functionalChannels[self._channel].label
-            elif len(self._device.functionalChannels) > 1:
-                name = self._device.functionalChannels[1].label
+                label = getattr(self.functional_channel, "label", None)
+                if label:
+                    name = str(label)
+            elif len(functional_channels) > 1:
+                label = getattr(functional_channels[1], "label", None)
+                if label:
+                    name = str(label)
 
         # Use device label, if name is not defined by channel label.
         if not name:
-            name = self._device.label
+            name = self._device.label or ""
             if self._post:
                 name = f"{name} {self._post}"
             elif self._is_multi_channel:
-                name = f"{name} Channel{self._channel}"
+                name = f"{name} Channel{self.get_channel_index()}"
 
         # Add a prefix to the name if the homematic ip home has a name.
-        if name and self._home.name:
-            name = f"{self._home.name} {name}"
+        home_name = getattr(self._home, "name", None)
+        if name and home_name:
+            name = f"{home_name} {name}"
 
         return name
 
@@ -217,9 +239,7 @@ class HomematicipGenericEntity(Entity):
         """Return a unique ID."""
         unique_id = f"{self.__class__.__name__}_{self._device.id}"
         if self._is_multi_channel:
-            unique_id = (
-                f"{self.__class__.__name__}_Channel{self._channel}_{self._device.id}"
-            )
+            unique_id = f"{self.__class__.__name__}_Channel{self.get_channel_index()}_{self._device.id}"
 
         return unique_id
 
@@ -254,12 +274,65 @@ class HomematicipGenericEntity(Entity):
         return state_attr
 
     def get_current_channel(self) -> FunctionalChannel:
-        """Return the FunctionalChannel for device."""
-        if hasattr(self._device, "functionalChannels"):
-            if self._is_multi_channel:
-                return self._device.functionalChannels[self._channel]
+        """Return the FunctionalChannel for the device.
 
-            if len(self._device.functionalChannels) > 1:
-                return self._device.functionalChannels[1]
+        Resolution priority:
+        1. For multi-channel entities with a real index, find channel by index match.
+        2. For multi-channel entities without a real index, use the provided channel position.
+        3. For non multi-channel entities with >1 channels, use channel at position 1
+           (index 0 is often a meta/service channel in HmIP).
+        Raises ValueError if no suitable channel can be resolved.
+        """
+        functional_channels = getattr(self._device, "functionalChannels", None)
+        if not functional_channels:
+            raise ValueError(
+                f"Device {getattr(self._device, 'id', 'unknown')} has no functionalChannels"
+            )
 
-        return None
+        # Multi-channel handling
+        if self._is_multi_channel:
+            # Prefer real index mapping when provided to avoid ordering issues.
+            if self._channel_real_index is not None:
+                for channel in functional_channels:
+                    if channel.index == self._channel_real_index:
+                        return channel
+                raise ValueError(
+                    f"Real channel index {self._channel_real_index} not found for device "
+                    f"{getattr(self._device, 'id', 'unknown')}"
+                )
+            # Fallback: positional channel (already sorted as strings upstream).
+            if self._channel is not None and 0 <= self._channel < len(
+                functional_channels
+            ):
+                return functional_channels[self._channel]
+            raise ValueError(
+                f"Channel position {self._channel} invalid for device "
+                f"{getattr(self._device, 'id', 'unknown')} (len={len(functional_channels)})"
+            )
+
+        # Single-channel / non multi-channel entity: choose second element if available
+        if len(functional_channels) > 1:
+            return functional_channels[1]
+        return functional_channels[0]
+
+    def get_channel_index(self) -> int:
+        """Return the correct channel index for this entity.
+
+        Prefers channel_real_index if set, otherwise returns channel.
+        This ensures the correct channel is used even if the functionalChannels list is not numerically ordered.
+        """
+        if self._channel_real_index is not None:
+            return self._channel_real_index
+
+        if self._channel is not None:
+            return self._channel
+
+        return 1
+
+    def get_channel_or_raise(self) -> FunctionalChannel:
+        """Return the FunctionalChannel or raise an error if not found."""
+        if not self.functional_channel:
+            raise ValueError(
+                f"No functional channel found for device {getattr(self._device, 'id', 'unknown')}"
+            )
+        return self.functional_channel

homeassistant/components/homematicip_cloud/event.py

@@ -92,7 +92,9 @@ class HomematicipDoorBellEvent(HomematicipGenericEntity, EventEntity):
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""
         await super().async_added_to_hass()
-        self.functional_channel.add_on_channel_event_handler(self._async_handle_event)
+
+        channel = self.get_channel_or_raise()
+        channel.add_on_channel_event_handler(self._async_handle_event)
 
     @callback
     def _async_handle_event(self, *args, **kwargs) -> None:

homeassistant/components/homematicip_cloud/light.py

@@ -134,49 +134,49 @@ class HomematicipLightHS(HomematicipGenericEntity, LightEntity):
     @property
     def is_on(self) -> bool:
         """Return true if light is on."""
-        return self.functional_channel.on
+        channel = self.get_channel_or_raise()
+        return channel.on
 
     @property
     def brightness(self) -> int | None:
         """Return the current brightness."""
-        return int(self.functional_channel.dimLevel * 255.0)
+        channel = self.get_channel_or_raise()
+        return int(channel.dimLevel * 255.0)
 
     @property
     def hs_color(self) -> tuple[float, float] | None:
         """Return the hue and saturation color value [float, float]."""
-        if (
-            self.functional_channel.hue is None
-            or self.functional_channel.saturationLevel is None
-        ):
+        channel = self.get_channel_or_raise()
+        if channel.hue is None or channel.saturationLevel is None:
             return None
         return (
-            self.functional_channel.hue,
-            self.functional_channel.saturationLevel * 100.0,
+            channel.hue,
+            channel.saturationLevel * 100.0,
         )
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the light on."""
-
+        channel = self.get_channel_or_raise()
         hs_color = kwargs.get(ATTR_HS_COLOR, (0.0, 0.0))
         hue = hs_color[0] % 360.0
         saturation = hs_color[1] / 100.0
         dim_level = round(kwargs.get(ATTR_BRIGHTNESS, 255) / 255.0, 2)
 
         if ATTR_HS_COLOR not in kwargs:
-            hue = self.functional_channel.hue
-            saturation = self.functional_channel.saturationLevel
+            hue = channel.hue
+            saturation = channel.saturationLevel
 
         if ATTR_BRIGHTNESS not in kwargs:
             # If no brightness is set, use the current brightness
-            dim_level = self.functional_channel.dimLevel or 1.0
-
-        await self.functional_channel.set_hue_saturation_dim_level_async(
+            dim_level = channel.dimLevel or 1.0
+        await channel.set_hue_saturation_dim_level_async(
             hue=hue, saturation_level=saturation, dim_level=dim_level
         )
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the light off."""
-        await self.functional_channel.set_switch_state_async(on=False)
+        channel = self.get_channel_or_raise()
+        await channel.set_switch_state_async(on=False)
 
 
 class HomematicipLightMeasuring(HomematicipLight):

homeassistant/components/homematicip_cloud/sensor.py

@@ -307,7 +307,8 @@ class HomematicipWaterFlowSensor(HomematicipGenericEntity, SensorEntity):
     @property
     def native_value(self) -> float | None:
         """Return the state."""
-        return self.functional_channel.waterFlow
+        channel = self.get_channel_or_raise()
+        return channel.waterFlow
 
 
 class HomematicipWaterVolumeSensor(HomematicipGenericEntity, SensorEntity):