sort common state strings

https://github.com/home-assistant/core/pull/139270#discussion_r1970315129

.github/workflows/builder.yml

@@ -69,7 +69,7 @@ jobs:
         run: find ./homeassistant/components/*/translations -name "*.json" | tar zcvf translations.tar.gz -T -
 
       - name: Upload translations
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: translations
           path: translations.tar.gz
@@ -324,7 +324,7 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Install Cosign
-        uses: sigstore/cosign-installer@v3.8.0
+        uses: sigstore/cosign-installer@v3.8.1
         with:
           cosign-release: "v2.2.3"
 
@@ -448,6 +448,9 @@ jobs:
     environment: ${{ needs.init.outputs.channel }}
     needs: ["init", "build_base"]
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
@@ -473,16 +476,13 @@ jobs:
         run: |
           # Remove dist, build, and homeassistant.egg-info
           # when build locally for testing!
-          pip install twine build
+          pip install build
           python -m build
 
-      - name: Upload package
-        shell: bash
-        run: |
-          export TWINE_USERNAME="__token__"
-          export TWINE_PASSWORD="${{ secrets.TWINE_TOKEN }}"
-
-          twine upload dist/* --skip-existing
+      - name: Upload package to PyPI
+        uses: pypa/gh-action-pypi-publish@v1.12.4
+        with:
+          skip-existing: true
 
   hassfest-image:
     name: Build and test hassfest image

.github/workflows/ci.yaml

@@ -537,7 +537,7 @@ jobs:
           python --version
           uv pip freeze >> pip_freeze.txt
       - name: Upload pip_freeze artifact
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: pip-freeze-${{ matrix.python-version }}
           path: pip_freeze.txt
@@ -661,7 +661,7 @@ jobs:
           . venv/bin/activate
           python -m script.licenses extract --output-file=licenses-${{ matrix.python-version }}.json
       - name: Upload licenses
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: licenses-${{ github.run_number }}-${{ matrix.python-version }}
           path: licenses-${{ matrix.python-version }}.json
@@ -877,7 +877,7 @@ jobs:
           . venv/bin/activate
           python -m script.split_tests ${{ needs.info.outputs.test_group_count }} tests
       - name: Upload pytest_buckets
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: pytest_buckets
           path: pytest_buckets.txt
@@ -980,14 +980,14 @@ jobs:
               2>&1 | tee pytest-${{ matrix.python-version }}-${{ matrix.group }}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-full.conclusion == 'failure'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{ matrix.group }}
           path: pytest-*.txt
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml
@@ -1108,7 +1108,7 @@ jobs:
               2>&1 | tee pytest-${{ matrix.python-version }}-${mariadb}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-partial.conclusion == 'failure'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.mariadb }}
@@ -1116,7 +1116,7 @@ jobs:
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: coverage-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.mariadb }}
@@ -1239,7 +1239,7 @@ jobs:
               2>&1 | tee pytest-${{ matrix.python-version }}-${postgresql}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-partial.conclusion == 'failure'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.postgresql }}
@@ -1247,7 +1247,7 @@ jobs:
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: coverage-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.postgresql }}
@@ -1382,14 +1382,14 @@ jobs:
               2>&1 | tee pytest-${{ matrix.python-version }}-${{ matrix.group }}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-partial.conclusion == 'failure'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{ matrix.group }}
           path: pytest-*.txt
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.28.9
+        uses: github/codeql-action/init@v3.28.10
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.28.9
+        uses: github/codeql-action/analyze@v3.28.10
         with:
           category: "/language:python"

.github/workflows/wheels.yml

@@ -91,7 +91,7 @@ jobs:
           ) > build_constraints.txt
 
       - name: Upload env_file
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: env_file
           path: ./.env_file
@@ -99,14 +99,14 @@ jobs:
           overwrite: true
 
       - name: Upload build_constraints
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: build_constraints
           path: ./build_constraints.txt
           overwrite: true
 
       - name: Upload requirements_diff
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: requirements_diff
           path: ./requirements_diff.txt
@@ -118,7 +118,7 @@ jobs:
           python -m script.gen_requirements_all ci
 
       - name: Upload requirements_all_wheels
-        uses: actions/upload-artifact@v4.6.0
+        uses: actions/upload-artifact@v4.6.1
         with:
           name: requirements_all_wheels
           path: ./requirements_all_wheels_*.txt

.strict-typing

@@ -103,6 +103,7 @@ homeassistant.components.auth.*
 homeassistant.components.automation.*
 homeassistant.components.awair.*
 homeassistant.components.axis.*
+homeassistant.components.azure_storage.*
 homeassistant.components.backup.*
 homeassistant.components.baf.*
 homeassistant.components.bang_olufsen.*
@@ -407,6 +408,7 @@ homeassistant.components.raspberry_pi.*
 homeassistant.components.rdw.*
 homeassistant.components.recollect_waste.*
 homeassistant.components.recorder.*
+homeassistant.components.remember_the_milk.*
 homeassistant.components.remote.*
 homeassistant.components.renault.*
 homeassistant.components.reolink.*

.vscode/launch.json

@@ -42,6 +42,14 @@
         "--picked"
       ],
     },
+    {
+      "name": "Home Assistant: Debug Current Test File",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "pytest",
+      "console": "integratedTerminal",
+      "args": ["-vv", "${file}"]
+    },
     {
       // Debug by attaching to local Home Assistant server using Remote Python Debugger.
       // See https://www.home-assistant.io/integrations/debugpy/
@@ -77,4 +85,4 @@
       ]
     }
   ]
-}
+}

CODEOWNERS

@@ -180,6 +180,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/azure_event_hub/ @eavanvalkenburg
 /tests/components/azure_event_hub/ @eavanvalkenburg
 /homeassistant/components/azure_service_bus/ @hfurubotten
+/homeassistant/components/azure_storage/ @zweckj
+/tests/components/azure_storage/ @zweckj
 /homeassistant/components/backup/ @home-assistant/core
 /tests/components/backup/ @home-assistant/core
 /homeassistant/components/baf/ @bdraco @jfroy
@@ -967,8 +969,8 @@ build.json @home-assistant/supervisor
 /tests/components/motionblinds_ble/ @LennP @jerrybboy
 /homeassistant/components/motioneye/ @dermotduffy
 /tests/components/motioneye/ @dermotduffy
-/homeassistant/components/motionmount/ @RJPoelstra
-/tests/components/motionmount/ @RJPoelstra
+/homeassistant/components/motionmount/ @laiho-vogels
+/tests/components/motionmount/ @laiho-vogels
 /homeassistant/components/mqtt/ @emontnemery @jbouwh @bdraco
 /tests/components/mqtt/ @emontnemery @jbouwh @bdraco
 /homeassistant/components/msteams/ @peroyvind
@@ -1051,8 +1053,8 @@ build.json @home-assistant/supervisor
 /tests/components/numato/ @clssn
 /homeassistant/components/number/ @home-assistant/core @Shulyaka
 /tests/components/number/ @home-assistant/core @Shulyaka
-/homeassistant/components/nut/ @bdraco @ollo69 @pestevez
-/tests/components/nut/ @bdraco @ollo69 @pestevez
+/homeassistant/components/nut/ @bdraco @ollo69 @pestevez @tdfountain
+/tests/components/nut/ @bdraco @ollo69 @pestevez @tdfountain
 /homeassistant/components/nws/ @MatthewFlamm @kamiyo
 /tests/components/nws/ @MatthewFlamm @kamiyo
 /homeassistant/components/nyt_games/ @joostlek
@@ -1144,8 +1146,8 @@ build.json @home-assistant/supervisor
 /tests/components/philips_js/ @elupus
 /homeassistant/components/pi_hole/ @shenxn
 /tests/components/pi_hole/ @shenxn
-/homeassistant/components/picnic/ @corneyl
-/tests/components/picnic/ @corneyl
+/homeassistant/components/picnic/ @corneyl @codesalatdev
+/tests/components/picnic/ @corneyl @codesalatdev
 /homeassistant/components/ping/ @jpbede
 /tests/components/ping/ @jpbede
 /homeassistant/components/plaato/ @JohNan
@@ -1413,6 +1415,8 @@ build.json @home-assistant/supervisor
 /tests/components/snapcast/ @luar123
 /homeassistant/components/snmp/ @nmaggioni
 /tests/components/snmp/ @nmaggioni
+/homeassistant/components/snoo/ @Lash-L
+/tests/components/snoo/ @Lash-L
 /homeassistant/components/snooz/ @AustinBrunkhorst
 /tests/components/snooz/ @AustinBrunkhorst
 /homeassistant/components/solaredge/ @frenck @bdraco
@@ -1693,6 +1697,8 @@ build.json @home-assistant/supervisor
 /tests/components/weatherflow_cloud/ @jeeftor
 /homeassistant/components/weatherkit/ @tjhorner
 /tests/components/weatherkit/ @tjhorner
+/homeassistant/components/webdav/ @jpbede
+/tests/components/webdav/ @jpbede
 /homeassistant/components/webhook/ @home-assistant/core
 /tests/components/webhook/ @home-assistant/core
 /homeassistant/components/webmin/ @autinerd

homeassistant/bootstrap.py

@@ -74,6 +74,7 @@ from .core_config import async_process_ha_core_config
 from .exceptions import HomeAssistantError
 from .helpers import (
     area_registry,
+    backup,
     category_registry,
     config_validation as cv,
     device_registry,
@@ -163,16 +164,6 @@ FRONTEND_INTEGRATIONS = {
     # integrations can be removed and database migration status is
     # visible in frontend
     "frontend",
-    # Hassio is an after dependency of backup, after dependencies
-    # are not promoted from stage 2 to earlier stages, so we need to
-    # add it here. Hassio needs to be setup before backup, otherwise
-    # the backup integration will think we are a container/core install
-    # when using HAOS or Supervised install.
-    "hassio",
-    # Backup is an after dependency of frontend, after dependencies
-    # are not promoted from stage 2 to earlier stages, so we need to
-    # add it here.
-    "backup",
 }
 # Stage 0 is divided into substages. Each substage has a name, a set of integrations and a timeout.
 # The substage containing recorder should have no timeout, as it could cancel a database migration.
@@ -206,6 +197,8 @@ STAGE_1_INTEGRATIONS = {
     "mqtt_eventstream",
     # To provide account link implementations
     "cloud",
+    # Ensure supervisor is available
+    "hassio",
 }
 
 DEFAULT_INTEGRATIONS = {
@@ -328,10 +321,10 @@ async def async_setup_hass(
 
     block_async_io.enable()
 
-    config_dict = None
-    basic_setup_success = False
-
     if not (recovery_mode := runtime_config.recovery_mode):
+        config_dict = None
+        basic_setup_success = False
+
         await hass.async_add_executor_job(conf_util.process_ha_config_upgrade, hass)
 
         try:
@@ -349,39 +342,43 @@ async def async_setup_hass(
                 await async_from_config_dict(config_dict, hass) is not None
             )
 
-    if config_dict is None:
-        recovery_mode = True
-        await stop_hass(hass)
-        hass = await create_hass()
+        if config_dict is None:
+            recovery_mode = True
+            await stop_hass(hass)
+            hass = await create_hass()
 
-    elif not basic_setup_success:
-        _LOGGER.warning("Unable to set up core integrations. Activating recovery mode")
-        recovery_mode = True
-        await stop_hass(hass)
-        hass = await create_hass()
+        elif not basic_setup_success:
+            _LOGGER.warning(
+                "Unable to set up core integrations. Activating recovery mode"
+            )
+            recovery_mode = True
+            await stop_hass(hass)
+            hass = await create_hass()
 
-    elif any(domain not in hass.config.components for domain in CRITICAL_INTEGRATIONS):
-        _LOGGER.warning(
-            "Detected that %s did not load. Activating recovery mode",
-            ",".join(CRITICAL_INTEGRATIONS),
-        )
+        elif any(
+            domain not in hass.config.components for domain in CRITICAL_INTEGRATIONS
+        ):
+            _LOGGER.warning(
+                "Detected that %s did not load. Activating recovery mode",
+                ",".join(CRITICAL_INTEGRATIONS),
+            )
 
-        old_config = hass.config
-        old_logging = hass.data.get(DATA_LOGGING)
+            old_config = hass.config
+            old_logging = hass.data.get(DATA_LOGGING)
 
-        recovery_mode = True
-        await stop_hass(hass)
-        hass = await create_hass()
+            recovery_mode = True
+            await stop_hass(hass)
+            hass = await create_hass()
 
-        if old_logging:
-            hass.data[DATA_LOGGING] = old_logging
-        hass.config.debug = old_config.debug
-        hass.config.skip_pip = old_config.skip_pip
-        hass.config.skip_pip_packages = old_config.skip_pip_packages
-        hass.config.internal_url = old_config.internal_url
-        hass.config.external_url = old_config.external_url
-        # Setup loader cache after the config dir has been set
-        loader.async_setup(hass)
+            if old_logging:
+                hass.data[DATA_LOGGING] = old_logging
+            hass.config.debug = old_config.debug
+            hass.config.skip_pip = old_config.skip_pip
+            hass.config.skip_pip_packages = old_config.skip_pip_packages
+            hass.config.internal_url = old_config.internal_url
+            hass.config.external_url = old_config.external_url
+            # Setup loader cache after the config dir has been set
+            loader.async_setup(hass)
 
     if recovery_mode:
         _LOGGER.info("Starting in recovery mode")
@@ -901,6 +898,10 @@ async def _async_set_up_integrations(
     if "recorder" in domains_to_setup:
         recorder.async_initialize_recorder(hass)
 
+    # Initialize backup
+    if "backup" in domains_to_setup:
+        backup.async_initialize_backup(hass)
+
     stage_0_and_1_domains: list[tuple[str, set[str], int | None]] = [
         *(
             (name, domain_group & domains_to_setup, timeout)

homeassistant/brands/microsoft.json

@@ -6,6 +6,7 @@
     "azure_devops",
     "azure_event_hub",
     "azure_service_bus",
+    "azure_storage",
     "microsoft_face_detect",
     "microsoft_face_identify",
     "microsoft_face",

homeassistant/components/alarmdecoder/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["adext", "alarmdecoder"],
-  "requirements": ["adext==0.4.3"]
+  "requirements": ["adext==0.4.4"]
 }

homeassistant/components/androidtv_remote/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["androidtvremote2"],
-  "requirements": ["androidtvremote2==0.1.2"],
+  "requirements": ["androidtvremote2==0.2.0"],
   "zeroconf": ["_androidtvremote2._tcp.local."]
 }

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.44.0"]
+  "requirements": ["anthropic==0.47.2"]
 }

homeassistant/components/azure_storage/__init__.py

@@ -0,0 +1,82 @@
+"""The Azure Storage integration."""
+
+from aiohttp import ClientTimeout
+from azure.core.exceptions import (
+    ClientAuthenticationError,
+    HttpResponseError,
+    ResourceNotFoundError,
+)
+from azure.core.pipeline.transport._aiohttp import (
+    AioHttpTransport,
+)  # need to import from private file, as it is not properly imported in the init
+from azure.storage.blob.aio import ContainerClient
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
+
+from .const import (
+    CONF_ACCOUNT_NAME,
+    CONF_CONTAINER_NAME,
+    CONF_STORAGE_ACCOUNT_KEY,
+    DATA_BACKUP_AGENT_LISTENERS,
+    DOMAIN,
+)
+
+type AzureStorageConfigEntry = ConfigEntry[ContainerClient]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: AzureStorageConfigEntry
+) -> bool:
+    """Set up Azure Storage integration."""
+    # set increase aiohttp timeout for long running operations (up/download)
+    session = async_create_clientsession(
+        hass, timeout=ClientTimeout(connect=10, total=12 * 60 * 60)
+    )
+    container_client = ContainerClient(
+        account_url=f"https://{entry.data[CONF_ACCOUNT_NAME]}.blob.core.windows.net/",
+        container_name=entry.data[CONF_CONTAINER_NAME],
+        credential=entry.data[CONF_STORAGE_ACCOUNT_KEY],
+        transport=AioHttpTransport(session=session),
+    )
+
+    try:
+        if not await container_client.exists():
+            await container_client.create_container()
+    except ResourceNotFoundError as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="account_not_found",
+            translation_placeholders={CONF_ACCOUNT_NAME: entry.data[CONF_ACCOUNT_NAME]},
+        ) from err
+    except ClientAuthenticationError as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_auth",
+            translation_placeholders={CONF_ACCOUNT_NAME: entry.data[CONF_ACCOUNT_NAME]},
+        ) from err
+    except HttpResponseError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="cannot_connect",
+            translation_placeholders={CONF_ACCOUNT_NAME: entry.data[CONF_ACCOUNT_NAME]},
+        ) from err
+
+    entry.runtime_data = container_client
+
+    def _async_notify_backup_listeners() -> None:
+        for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
+            listener()
+
+    entry.async_on_unload(entry.async_on_state_change(_async_notify_backup_listeners))
+
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, entry: AzureStorageConfigEntry
+) -> bool:
+    """Unload an Azure Storage config entry."""
+    return True

homeassistant/components/azure_storage/backup.py

@@ -0,0 +1,182 @@
+"""Support for Azure Storage backup."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Callable, Coroutine
+from functools import wraps
+import json
+import logging
+from typing import Any, Concatenate
+
+from azure.core.exceptions import HttpResponseError
+from azure.storage.blob import BlobProperties
+
+from homeassistant.components.backup import (
+    AgentBackup,
+    BackupAgent,
+    BackupAgentError,
+    BackupNotFound,
+    suggested_filename,
+)
+from homeassistant.core import HomeAssistant, callback
+
+from . import AzureStorageConfigEntry
+from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+METADATA_VERSION = "1"
+
+
+async def async_get_backup_agents(
+    hass: HomeAssistant,
+) -> list[BackupAgent]:
+    """Return a list of backup agents."""
+    entries: list[AzureStorageConfigEntry] = hass.config_entries.async_loaded_entries(
+        DOMAIN
+    )
+    return [AzureStorageBackupAgent(hass, entry) for entry in entries]
+
+
+@callback
+def async_register_backup_agents_listener(
+    hass: HomeAssistant,
+    *,
+    listener: Callable[[], None],
+    **kwargs: Any,
+) -> Callable[[], None]:
+    """Register a listener to be called when agents are added or removed."""
+    hass.data.setdefault(DATA_BACKUP_AGENT_LISTENERS, []).append(listener)
+
+    @callback
+    def remove_listener() -> None:
+        """Remove the listener."""
+        hass.data[DATA_BACKUP_AGENT_LISTENERS].remove(listener)
+        if not hass.data[DATA_BACKUP_AGENT_LISTENERS]:
+            hass.data.pop(DATA_BACKUP_AGENT_LISTENERS)
+
+    return remove_listener
+
+
+def handle_backup_errors[_R, **P](
+    func: Callable[Concatenate[AzureStorageBackupAgent, P], Coroutine[Any, Any, _R]],
+) -> Callable[Concatenate[AzureStorageBackupAgent, P], Coroutine[Any, Any, _R]]:
+    """Handle backup errors."""
+
+    @wraps(func)
+    async def wrapper(
+        self: AzureStorageBackupAgent, *args: P.args, **kwargs: P.kwargs
+    ) -> _R:
+        try:
+            return await func(self, *args, **kwargs)
+        except HttpResponseError as err:
+            _LOGGER.debug(
+                "Error during backup in %s: Status %s, message %s",
+                func.__name__,
+                err.status_code,
+                err.message,
+                exc_info=True,
+            )
+            raise BackupAgentError(
+                f"Error during backup operation in {func.__name__}:"
+                f" Status {err.status_code}, message: {err.message}"
+            ) from err
+
+    return wrapper
+
+
+class AzureStorageBackupAgent(BackupAgent):
+    """Azure storage backup agent."""
+
+    domain = DOMAIN
+
+    def __init__(self, hass: HomeAssistant, entry: AzureStorageConfigEntry) -> None:
+        """Initialize the Azure storage backup agent."""
+        super().__init__()
+        self._client = entry.runtime_data
+        self.name = entry.title
+        self.unique_id = entry.entry_id
+
+    @handle_backup_errors
+    async def async_download_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> AsyncIterator[bytes]:
+        """Download a backup file."""
+        blob = await self._find_blob_by_backup_id(backup_id)
+        if blob is None:
+            raise BackupNotFound(f"Backup {backup_id} not found")
+        download_stream = await self._client.download_blob(blob.name)
+        return download_stream.chunks()
+
+    @handle_backup_errors
+    async def async_upload_backup(
+        self,
+        *,
+        open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
+        backup: AgentBackup,
+        **kwargs: Any,
+    ) -> None:
+        """Upload a backup."""
+
+        metadata = {
+            "metadata_version": METADATA_VERSION,
+            "backup_id": backup.backup_id,
+            "backup_metadata": json.dumps(backup.as_dict()),
+        }
+
+        await self._client.upload_blob(
+            name=suggested_filename(backup),
+            metadata=metadata,
+            data=await open_stream(),
+            length=backup.size,
+        )
+
+    @handle_backup_errors
+    async def async_delete_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> None:
+        """Delete a backup file."""
+        blob = await self._find_blob_by_backup_id(backup_id)
+        if blob is None:
+            return
+        await self._client.delete_blob(blob.name)
+
+    @handle_backup_errors
+    async def async_list_backups(self, **kwargs: Any) -> list[AgentBackup]:
+        """List backups."""
+        backups: list[AgentBackup] = []
+        async for blob in self._client.list_blobs(include="metadata"):
+            metadata = blob.metadata
+
+            if metadata.get("metadata_version") == METADATA_VERSION:
+                backups.append(
+                    AgentBackup.from_dict(json.loads(metadata["backup_metadata"]))
+                )
+
+        return backups
+
+    @handle_backup_errors
+    async def async_get_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> AgentBackup | None:
+        """Return a backup."""
+        blob = await self._find_blob_by_backup_id(backup_id)
+        if blob is None:
+            return None
+
+        return AgentBackup.from_dict(json.loads(blob.metadata["backup_metadata"]))
+
+    async def _find_blob_by_backup_id(self, backup_id: str) -> BlobProperties | None:
+        """Find a blob by backup id."""
+        async for blob in self._client.list_blobs(include="metadata"):
+            if (
+                backup_id == blob.metadata.get("backup_id", "")
+                and blob.metadata.get("metadata_version") == METADATA_VERSION
+            ):
+                return blob
+        return None

homeassistant/components/azure_storage/config_flow.py

@@ -0,0 +1,72 @@
+"""Config flow for Azure Storage integration."""
+
+import logging
+from typing import Any
+
+from azure.core.exceptions import ClientAuthenticationError, ResourceNotFoundError
+from azure.core.pipeline.transport._aiohttp import (
+    AioHttpTransport,
+)  # need to import from private file, as it is not properly imported in the init
+from azure.storage.blob.aio import ContainerClient
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import (
+    CONF_ACCOUNT_NAME,
+    CONF_CONTAINER_NAME,
+    CONF_STORAGE_ACCOUNT_KEY,
+    DOMAIN,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AzureStorageConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for azure storage."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """User step for Azure Storage."""
+
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            self._async_abort_entries_match(
+                {CONF_ACCOUNT_NAME: user_input[CONF_ACCOUNT_NAME]}
+            )
+            container_client = ContainerClient(
+                account_url=f"https://{user_input[CONF_ACCOUNT_NAME]}.blob.core.windows.net/",
+                container_name=user_input[CONF_CONTAINER_NAME],
+                credential=user_input[CONF_STORAGE_ACCOUNT_KEY],
+                transport=AioHttpTransport(session=async_get_clientsession(self.hass)),
+            )
+            try:
+                await container_client.exists()
+            except ResourceNotFoundError:
+                errors["base"] = "cannot_connect"
+            except ClientAuthenticationError:
+                errors[CONF_STORAGE_ACCOUNT_KEY] = "invalid_auth"
+            except Exception:
+                _LOGGER.exception("Unknown exception occurred")
+                errors["base"] = "unknown"
+            if not errors:
+                return self.async_create_entry(
+                    title=f"{user_input[CONF_ACCOUNT_NAME]}/{user_input[CONF_CONTAINER_NAME]}",
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ACCOUNT_NAME): str,
+                    vol.Required(
+                        CONF_CONTAINER_NAME, default="home-assistant-backups"
+                    ): str,
+                    vol.Required(CONF_STORAGE_ACCOUNT_KEY): str,
+                }
+            ),
+            errors=errors,
+        )

homeassistant/components/azure_storage/const.py

@@ -0,0 +1,16 @@
+"""Constants for the Azure Storage integration."""
+
+from collections.abc import Callable
+from typing import Final
+
+from homeassistant.util.hass_dict import HassKey
+
+DOMAIN: Final = "azure_storage"
+
+CONF_STORAGE_ACCOUNT_KEY: Final = "storage_account_key"
+CONF_ACCOUNT_NAME: Final = "account_name"
+CONF_CONTAINER_NAME: Final = "container_name"
+
+DATA_BACKUP_AGENT_LISTENERS: HassKey[list[Callable[[], None]]] = HassKey(
+    f"{DOMAIN}.backup_agent_listeners"
+)

homeassistant/components/azure_storage/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "azure_storage",
+  "name": "Azure Storage",
+  "codeowners": ["@zweckj"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/azure_storage",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "loggers": ["azure-storage-blob"],
+  "quality_scale": "bronze",
+  "requirements": ["azure-storage-blob==12.24.0"]
+}

homeassistant/components/azure_storage/quality_scale.yaml

@@ -0,0 +1,133 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions.
+  appropriate-polling:
+    status: exempt
+    comment: |
+      This integration does not poll.
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      This integration does not have any custom actions.
+  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:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  has-entity-name:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  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:
+    status: exempt
+    comment: |
+      This integration does not have any configuration parameters.
+  docs-installation-parameters: done
+  entity-unavailable:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  integration-owner: done
+  log-when-unavailable:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  parallel-updates:
+    status: exempt
+    comment: |
+      This integration does not have platforms.
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices:
+    status: exempt
+    comment: |
+      This integration connects to a single service.
+  diagnostics:
+    status: exempt
+    comment: |
+      There is no data to diagnose.
+  discovery-update-info:
+    status: exempt
+    comment: |
+      This integration is a cloud service and does not support discovery.
+  discovery:
+    status: exempt
+    comment: |
+      This integration is a cloud service and does not support discovery.
+  docs-data-update:
+    status: exempt
+    comment: |
+      This integration does not poll or push.
+  docs-examples:
+    status: exempt
+    comment: |
+      This integration only serves backup.
+  docs-known-limitations: done
+  docs-supported-devices:
+    status: exempt
+    comment: |
+      This integration is a cloud service.
+  docs-supported-functions:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices:
+    status: exempt
+    comment: |
+      This integration connects to a single service.
+  entity-category:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  entity-device-class:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  entity-disabled-by-default:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  entity-translations:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  exception-translations: done
+  icon-translations:
+    status: exempt
+    comment: |
+      This integration does not have entities.
+  reconfiguration-flow: todo
+  repair-issues: done
+  stale-devices:
+    status: exempt
+    comment: |
+      This integration connects to a single service.
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/azure_storage/strings.json

@@ -0,0 +1,48 @@
+{
+  "config": {
+    "error": {
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "storage_account_key": "Storage account key",
+          "account_name": "Account name",
+          "container_name": "Container name"
+        },
+        "data_description": {
+          "storage_account_key": "Storage account access key used for authorization",
+          "account_name": "Name of the storage account",
+          "container_name": "Name of the storage container to be used (will be created if it does not exist)"
+        },
+        "description": "Set up an Azure (Blob) storage account to be used for backups.",
+        "title": "Add Azure storage account"
+      }
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+    }
+  },
+  "issues": {
+    "container_not_found": {
+      "title": "Storage container not found",
+      "description": "The storage container {container_name} has not been found in the storage account. Please re-create it manually, then fix this issue."
+    }
+  },
+  "exceptions": {
+    "account_not_found": {
+      "message": "Storage account {account_name} not found"
+    },
+    "cannot_connect": {
+      "message": "Can not connect to storage account {account_name}"
+    },
+    "invalid_auth": {
+      "message": "Authentication failed for storage account {account_name}"
+    },
+    "container_not_found": {
+      "message": "Storage container {container_name} not found"
+    }
+  }
+}

homeassistant/components/backup/__init__.py

@@ -1,8 +1,8 @@
 """The Backup integration."""
 
-from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.backup import DATA_BACKUP
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.typing import ConfigType
 
@@ -32,6 +32,7 @@ from .manager import (
     IdleEvent,
     IncorrectPasswordError,
     ManagerBackup,
+    ManagerStateEvent,
     NewBackup,
     RestoreBackupEvent,
     RestoreBackupStage,
@@ -63,12 +64,12 @@ __all__ = [
     "IncorrectPasswordError",
     "LocalBackupAgent",
     "ManagerBackup",
+    "ManagerStateEvent",
     "NewBackup",
     "RestoreBackupEvent",
     "RestoreBackupStage",
     "RestoreBackupState",
     "WrittenBackup",
-    "async_get_manager",
     "suggested_filename",
     "suggested_filename_from_name_date",
 ]
@@ -91,7 +92,13 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     backup_manager = BackupManager(hass, reader_writer)
     hass.data[DATA_MANAGER] = backup_manager
-    await backup_manager.async_setup()
+    try:
+        await backup_manager.async_setup()
+    except Exception as err:
+        hass.data[DATA_BACKUP].manager_ready.set_exception(err)
+        raise
+    else:
+        hass.data[DATA_BACKUP].manager_ready.set_result(None)
 
     async_register_websocket_handlers(hass, with_hassio)
 
@@ -122,15 +129,3 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     async_register_http_views(hass)
 
     return True
-
-
-@callback
-def async_get_manager(hass: HomeAssistant) -> BackupManager:
-    """Get the backup manager instance.
-
-    Raises HomeAssistantError if the backup integration is not available.
-    """
-    if DATA_MANAGER not in hass.data:
-        raise HomeAssistantError("Backup integration is not available")
-
-    return hass.data[DATA_MANAGER]

homeassistant/components/backup/basic_websocket.py

@@ -0,0 +1,38 @@
+"""Websocket commands for the Backup integration."""
+
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.backup import async_subscribe_events
+
+from .const import DATA_MANAGER
+from .manager import ManagerStateEvent
+
+
+@callback
+def async_register_websocket_handlers(hass: HomeAssistant) -> None:
+    """Register websocket commands."""
+    websocket_api.async_register_command(hass, handle_subscribe_events)
+
+
+@websocket_api.require_admin
+@websocket_api.websocket_command({vol.Required("type"): "backup/subscribe_events"})
+@websocket_api.async_response
+async def handle_subscribe_events(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Subscribe to backup events."""
+
+    def on_event(event: ManagerStateEvent) -> None:
+        connection.send_message(websocket_api.event_message(msg["id"], event))
+
+    if DATA_MANAGER in hass.data:
+        manager = hass.data[DATA_MANAGER]
+        on_event(manager.last_event)
+    connection.subscriptions[msg["id"]] = async_subscribe_events(hass, on_event)
+    connection.send_result(msg["id"])

homeassistant/components/backup/config.py

@@ -12,16 +12,19 @@ from typing import TYPE_CHECKING, Self, TypedDict
 from cronsim import CronSim
 
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import issue_registry as ir
 from homeassistant.helpers.event import async_call_later, async_track_point_in_time
 from homeassistant.helpers.typing import UNDEFINED, UndefinedType
 from homeassistant.util import dt as dt_util
 
-from .const import LOGGER
+from .const import DOMAIN, LOGGER
 from .models import BackupManagerError, Folder
 
 if TYPE_CHECKING:
     from .manager import BackupManager, ManagerBackup
 
+AUTOMATIC_BACKUP_AGENTS_UNAVAILABLE_ISSUE_ID = "automatic_backup_agents_unavailable"
+
 CRON_PATTERN_DAILY = "{m} {h} * * *"
 CRON_PATTERN_WEEKLY = "{m} {h} * * {d}"
 
@@ -39,6 +42,7 @@ class StoredBackupConfig(TypedDict):
     """Represent the stored backup config."""
 
     agents: dict[str, StoredAgentConfig]
+    automatic_backups_configured: bool
     create_backup: StoredCreateBackupConfig
     last_attempted_automatic_backup: str | None
     last_completed_automatic_backup: str | None
@@ -51,6 +55,7 @@ class BackupConfigData:
     """Represent loaded backup config data."""
 
     agents: dict[str, AgentConfig]
+    automatic_backups_configured: bool  # only used by frontend
     create_backup: CreateBackupConfig
     last_attempted_automatic_backup: datetime | None = None
     last_completed_automatic_backup: datetime | None = None
@@ -88,6 +93,7 @@ class BackupConfigData:
                 agent_id: AgentConfig(protected=agent_data["protected"])
                 for agent_id, agent_data in data["agents"].items()
             },
+            automatic_backups_configured=data["automatic_backups_configured"],
             create_backup=CreateBackupConfig(
                 agent_ids=data["create_backup"]["agent_ids"],
                 include_addons=data["create_backup"]["include_addons"],
@@ -127,6 +133,7 @@ class BackupConfigData:
             agents={
                 agent_id: agent.to_dict() for agent_id, agent in self.agents.items()
             },
+            automatic_backups_configured=self.automatic_backups_configured,
             create_backup=self.create_backup.to_dict(),
             last_attempted_automatic_backup=last_attempted,
             last_completed_automatic_backup=last_completed,
@@ -142,10 +149,12 @@ class BackupConfig:
         """Initialize backup config."""
         self.data = BackupConfigData(
             agents={},
+            automatic_backups_configured=False,
             create_backup=CreateBackupConfig(),
             retention=RetentionConfig(),
             schedule=BackupSchedule(),
         )
+        self._hass = hass
         self._manager = manager
 
     def load(self, stored_config: StoredBackupConfig) -> None:
@@ -159,6 +168,7 @@ class BackupConfig:
         self,
         *,
         agents: dict[str, AgentParametersDict] | UndefinedType = UNDEFINED,
+        automatic_backups_configured: bool | UndefinedType = UNDEFINED,
         create_backup: CreateBackupParametersDict | UndefinedType = UNDEFINED,
         retention: RetentionParametersDict | UndefinedType = UNDEFINED,
         schedule: ScheduleParametersDict | UndefinedType = UNDEFINED,
@@ -172,8 +182,12 @@ class BackupConfig:
                     self.data.agents[agent_id] = replace(
                         self.data.agents[agent_id], **agent_config
                     )
+        if automatic_backups_configured is not UNDEFINED:
+            self.data.automatic_backups_configured = automatic_backups_configured
         if create_backup is not UNDEFINED:
             self.data.create_backup = replace(self.data.create_backup, **create_backup)
+            if "agent_ids" in create_backup:
+                check_unavailable_agents(self._hass, self._manager)
         if retention is not UNDEFINED:
             new_retention = RetentionConfig(**retention)
             if new_retention != self.data.retention:
@@ -554,3 +568,46 @@ async def delete_backups_exceeding_configured_count(manager: BackupManager) -> N
     await manager.async_delete_filtered_backups(
         include_filter=_automatic_backups_filter, delete_filter=_delete_filter
     )
+
+
+@callback
+def check_unavailable_agents(hass: HomeAssistant, manager: BackupManager) -> None:
+    """Check for unavailable agents."""
+    if missing_agent_ids := set(manager.config.data.create_backup.agent_ids) - set(
+        manager.backup_agents
+    ):
+        LOGGER.debug(
+            "Agents %s are configured for automatic backup but are unavailable",
+            missing_agent_ids,
+        )
+
+    # Remove issues for unavailable agents that are not unavailable anymore.
+    issue_registry = ir.async_get(hass)
+    existing_missing_agent_issue_ids = {
+        issue_id
+        for domain, issue_id in issue_registry.issues
+        if domain == DOMAIN
+        and issue_id.startswith(AUTOMATIC_BACKUP_AGENTS_UNAVAILABLE_ISSUE_ID)
+    }
+    current_missing_agent_issue_ids = {
+        f"{AUTOMATIC_BACKUP_AGENTS_UNAVAILABLE_ISSUE_ID}_{agent_id}": agent_id
+        for agent_id in missing_agent_ids
+    }
+    for issue_id in existing_missing_agent_issue_ids - set(
+        current_missing_agent_issue_ids
+    ):
+        ir.async_delete_issue(hass, DOMAIN, issue_id)
+    for issue_id, agent_id in current_missing_agent_issue_ids.items():
+        ir.async_create_issue(
+            hass,
+            DOMAIN,
+            issue_id,
+            is_fixable=False,
+            learn_more_url="homeassistant://config/backup",
+            severity=ir.IssueSeverity.WARNING,
+            translation_key="automatic_backup_agents_unavailable",
+            translation_placeholders={
+                "agent_id": agent_id,
+                "backup_settings": "/config/backup/settings",
+            },
+        )

homeassistant/components/backup/manager.py

@@ -32,7 +32,9 @@ from homeassistant.helpers import (
     instance_id,
     integration_platform,
     issue_registry as ir,
+    start,
 )
+from homeassistant.helpers.backup import DATA_BACKUP
 from homeassistant.helpers.json import json_bytes
 from homeassistant.util import dt as dt_util, json as json_util
 
@@ -46,6 +48,7 @@ from .agent import (
 from .config import (
     BackupConfig,
     CreateBackupParametersDict,
+    check_unavailable_agents,
     delete_backups_exceeding_configured_count,
 )
 from .const import (
@@ -332,7 +335,9 @@ class BackupManager:
         # Latest backup event and backup event subscribers
         self.last_event: ManagerStateEvent = IdleEvent()
         self.last_non_idle_event: ManagerStateEvent | None = None
-        self._backup_event_subscriptions: list[Callable[[ManagerStateEvent], None]] = []
+        self._backup_event_subscriptions = hass.data[
+            DATA_BACKUP
+        ].backup_event_subscriptions
 
     async def async_setup(self) -> None:
         """Set up the backup manager."""
@@ -414,6 +419,13 @@ class BackupManager:
             }
         )
 
+        @callback
+        def check_unavailable_agents_after_start(hass: HomeAssistant) -> None:
+            """Check unavailable agents after start."""
+            check_unavailable_agents(hass, self)
+
+        start.async_at_started(self.hass, check_unavailable_agents_after_start)
+
     async def _add_platform(
         self,
         hass: HomeAssistant,
@@ -1279,19 +1291,6 @@ class BackupManager:
         for subscription in self._backup_event_subscriptions:
             subscription(event)
 
-    @callback
-    def async_subscribe_events(
-        self,
-        on_event: Callable[[ManagerStateEvent], None],
-    ) -> Callable[[], None]:
-        """Subscribe events."""
-
-        def remove_subscription() -> None:
-            self._backup_event_subscriptions.remove(on_event)
-
-        self._backup_event_subscriptions.append(on_event)
-        return remove_subscription
-
     def _update_issue_backup_failed(self) -> None:
         """Update issue registry when a backup fails."""
         ir.async_create_issue(

homeassistant/components/backup/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "system",
   "iot_class": "calculated",
   "quality_scale": "internal",
-  "requirements": ["cronsim==2.6", "securetar==2025.1.4"]
+  "requirements": ["cronsim==2.6", "securetar==2025.2.1"]
 }

homeassistant/components/backup/store.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 STORE_DELAY_SAVE = 30
 STORAGE_KEY = DOMAIN
 STORAGE_VERSION = 1
-STORAGE_VERSION_MINOR = 4
+STORAGE_VERSION_MINOR = 5
 
 
 class StoredBackupData(TypedDict):
@@ -67,6 +67,11 @@ class _BackupStore(Store[StoredBackupData]):
                     data["config"]["retention"]["copies"] = None
                 if data["config"]["retention"]["days"] == 0:
                     data["config"]["retention"]["days"] = None
+            if old_minor_version < 5:
+                # Version 1.5 adds automatic_backups_configured
+                data["config"]["automatic_backups_configured"] = (
+                    data["config"]["create_backup"]["password"] is not None
+                )
 
         # Note: We allow reading data with major version 2.
         # Reject if major version is higher than 2.

homeassistant/components/backup/strings.json

@@ -1,5 +1,9 @@
 {
   "issues": {
+    "automatic_backup_agents_unavailable": {
+      "title": "The backup location {agent_id} is unavailable",
+      "description": "The backup location `{agent_id}` is unavailable but is still configured for automatic backups.\n\nPlease visit the [automatic backup configuration page]({backup_settings}) to review and update your backup locations. Backups will not be uploaded to selected locations that are unavailable."
+    },
     "automatic_backup_failed_create": {
       "title": "Automatic backup could not be created",
       "description": "The automatic backup could not be created. Please check the logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured."

homeassistant/components/backup/websocket.py

@@ -10,11 +10,7 @@ from homeassistant.helpers import config_validation as cv
 
 from .config import Day, ScheduleRecurrence
 from .const import DATA_MANAGER, LOGGER
-from .manager import (
-    DecryptOnDowloadNotSupported,
-    IncorrectPasswordError,
-    ManagerStateEvent,
-)
+from .manager import DecryptOnDowloadNotSupported, IncorrectPasswordError
 from .models import BackupNotFound, Folder
 
 
@@ -34,7 +30,6 @@ def async_register_websocket_handlers(hass: HomeAssistant, with_hassio: bool) ->
     websocket_api.async_register_command(hass, handle_create_with_automatic_settings)
     websocket_api.async_register_command(hass, handle_delete)
     websocket_api.async_register_command(hass, handle_restore)
-    websocket_api.async_register_command(hass, handle_subscribe_events)
 
     websocket_api.async_register_command(hass, handle_config_info)
     websocket_api.async_register_command(hass, handle_config_update)
@@ -352,6 +347,7 @@ async def handle_config_info(
     {
         vol.Required("type"): "backup/config/update",
         vol.Optional("agents"): vol.Schema({str: {"protected": bool}}),
+        vol.Optional("automatic_backups_configured"): bool,
         vol.Optional("create_backup"): vol.Schema(
             {
                 vol.Optional("agent_ids"): vol.All([str], vol.Unique()),
@@ -400,22 +396,3 @@ def handle_config_update(
     changes.pop("type")
     manager.config.update(**changes)
     connection.send_result(msg["id"])
-
-
-@websocket_api.require_admin
-@websocket_api.websocket_command({vol.Required("type"): "backup/subscribe_events"})
-@websocket_api.async_response
-async def handle_subscribe_events(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Subscribe to backup events."""
-
-    def on_event(event: ManagerStateEvent) -> None:
-        connection.send_message(websocket_api.event_message(msg["id"], event))
-
-    manager = hass.data[DATA_MANAGER]
-    on_event(manager.last_event)
-    connection.subscriptions[msg["id"]] = manager.async_subscribe_events(on_event)
-    connection.send_result(msg["id"])

homeassistant/components/blue_current/strings.json

@@ -28,7 +28,7 @@
         "name": "Activity",
         "state": {
           "available": "Available",
-          "charging": "Charging",
+          "charging": "[%key:common::state::charging%]",
           "unavailable": "Unavailable",
           "error": "Error",
           "offline": "Offline"

homeassistant/components/bluetooth/manifest.json

@@ -21,6 +21,6 @@
     "bluetooth-auto-recovery==1.4.4",
     "bluetooth-data-tools==1.23.4",
     "dbus-fast==2.33.0",
-    "habluetooth==3.22.1"
+    "habluetooth==3.24.0"
   ]
 }

homeassistant/components/bmw_connected_drive/strings.json

@@ -138,7 +138,7 @@
         "name": "Charging status",
         "state": {
           "default": "Default",
-          "charging": "Charging",
+          "charging": "[%key:common::state::charging%]",
           "error": "Error",
           "complete": "Complete",
           "fully_charged": "Fully charged",

homeassistant/components/burbank_water_and_power/__init__.py

@@ -0,0 +1 @@
+"""Virtual integration: Burbank Water and Power (BWP)."""

homeassistant/components/burbank_water_and_power/manifest.json

@@ -0,0 +1,6 @@
+{
+  "domain": "burbank_water_and_power",
+  "name": "Burbank Water and Power (BWP)",
+  "integration_type": "virtual",
+  "supported_by": "opower"
+}

homeassistant/components/cambridge_audio/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["aiostreammagic"],
   "quality_scale": "platinum",
-  "requirements": ["aiostreammagic==2.10.0"],
+  "requirements": ["aiostreammagic==2.11.0"],
   "zeroconf": ["_stream-magic._tcp.local.", "_smoip._tcp.local."]
 }

homeassistant/components/cisco_ios/device_tracker.py

@@ -104,7 +104,7 @@ class CiscoDeviceScanner(DeviceScanner):
         """Open connection to the router and get arp entries."""
 
         try:
-            cisco_ssh: pxssh.pxssh[str] = pxssh.pxssh(encoding="uft-8")
+            cisco_ssh: pxssh.pxssh[str] = pxssh.pxssh(encoding="utf-8")
             cisco_ssh.login(
                 self.host,
                 self.username,

homeassistant/components/demo/water_heater.py

@@ -30,10 +30,15 @@ async def async_setup_entry(
     async_add_entities(
         [
             DemoWaterHeater(
-                "Demo Water Heater", 119, UnitOfTemperature.FAHRENHEIT, False, "eco"
+                "Demo Water Heater", 119, UnitOfTemperature.FAHRENHEIT, False, "eco", 1
             ),
             DemoWaterHeater(
-                "Demo Water Heater Celsius", 45, UnitOfTemperature.CELSIUS, True, "eco"
+                "Demo Water Heater Celsius",
+                45,
+                UnitOfTemperature.CELSIUS,
+                True,
+                "eco",
+                1,
             ),
         ]
     )
@@ -52,6 +57,7 @@ class DemoWaterHeater(WaterHeaterEntity):
         unit_of_measurement: str,
         away: bool,
         current_operation: str,
+        target_temperature_step: float,
     ) -> None:
         """Initialize the water_heater device."""
         self._attr_name = name
@@ -74,6 +80,7 @@ class DemoWaterHeater(WaterHeaterEntity):
             "gas",
             "off",
         ]
+        self._attr_target_temperature_step = target_temperature_step
 
     def set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperatures."""

homeassistant/components/dhcp/manifest.json

@@ -14,8 +14,8 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "aiodhcpwatcher==1.1.0",
-    "aiodiscover==2.6.0",
-    "cached-ipaddress==0.8.0"
+    "aiodhcpwatcher==1.1.1",
+    "aiodiscover==2.6.1",
+    "cached-ipaddress==0.9.2"
   ]
 }

homeassistant/components/ecovacs/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ecovacs",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.10", "deebot-client==12.1.0"]
+  "requirements": ["py-sucks==0.9.10", "deebot-client==12.2.0"]
 }

homeassistant/components/enphase_envoy/strings.json

@@ -360,9 +360,9 @@
       "acb_battery_state": {
         "name": "Battery state",
         "state": {
-          "discharging": "Discharging",
+          "discharging": "[%key:common::state::discharging%]",
           "idle": "[%key:common::state::idle%]",
-          "charging": "Charging",
+          "charging": "[%key:common::state::charging%]",
           "full": "Full"
         }
       },

homeassistant/components/evohome/__init__.py

@@ -25,6 +25,7 @@ import voluptuous as vol
 
 from homeassistant.const import (
     ATTR_ENTITY_ID,
+    ATTR_MODE,
     CONF_PASSWORD,
     CONF_SCAN_INTERVAL,
     CONF_USERNAME,
@@ -40,11 +41,10 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey
 
 from .const import (
-    ATTR_DURATION_DAYS,
-    ATTR_DURATION_HOURS,
+    ATTR_DURATION,
     ATTR_DURATION_UNTIL,
-    ATTR_SYSTEM_MODE,
-    ATTR_ZONE_TEMP,
+    ATTR_PERIOD,
+    ATTR_SETPOINT,
     CONF_LOCATION_IDX,
     DOMAIN,
     SCAN_INTERVAL_DEFAULT,
@@ -81,7 +81,7 @@ RESET_ZONE_OVERRIDE_SCHEMA: Final = vol.Schema(
 SET_ZONE_OVERRIDE_SCHEMA: Final = vol.Schema(
     {
         vol.Required(ATTR_ENTITY_ID): cv.entity_id,
-        vol.Required(ATTR_ZONE_TEMP): vol.All(
+        vol.Required(ATTR_SETPOINT): vol.All(
             vol.Coerce(float), vol.Range(min=4.0, max=35.0)
         ),
         vol.Optional(ATTR_DURATION_UNTIL): vol.All(
@@ -222,7 +222,7 @@ def setup_service_functions(
     # Permanent-only modes will use this schema
     perm_modes = [m[SZ_SYSTEM_MODE] for m in modes if not m[SZ_CAN_BE_TEMPORARY]]
     if perm_modes:  # any of: "Auto", "HeatingOff": permanent only
-        schema = vol.Schema({vol.Required(ATTR_SYSTEM_MODE): vol.In(perm_modes)})
+        schema = vol.Schema({vol.Required(ATTR_MODE): vol.In(perm_modes)})
         system_mode_schemas.append(schema)
 
     modes = [m for m in modes if m[SZ_CAN_BE_TEMPORARY]]
@@ -232,8 +232,8 @@ def setup_service_functions(
     if temp_modes:  # any of: "AutoWithEco", permanent or for 0-24 hours
         schema = vol.Schema(
             {
-                vol.Required(ATTR_SYSTEM_MODE): vol.In(temp_modes),
-                vol.Optional(ATTR_DURATION_HOURS): vol.All(
+                vol.Required(ATTR_MODE): vol.In(temp_modes),
+                vol.Optional(ATTR_DURATION): vol.All(
                     cv.time_period,
                     vol.Range(min=timedelta(hours=0), max=timedelta(hours=24)),
                 ),
@@ -246,8 +246,8 @@ def setup_service_functions(
     if temp_modes:  # any of: "Away", "Custom", "DayOff", permanent or for 1-99 days
         schema = vol.Schema(
             {
-                vol.Required(ATTR_SYSTEM_MODE): vol.In(temp_modes),
-                vol.Optional(ATTR_DURATION_DAYS): vol.All(
+                vol.Required(ATTR_MODE): vol.In(temp_modes),
+                vol.Optional(ATTR_PERIOD): vol.All(
                     cv.time_period,
                     vol.Range(min=timedelta(days=1), max=timedelta(days=99)),
                 ),

homeassistant/components/evohome/climate.py

@@ -29,7 +29,7 @@ from homeassistant.components.climate import (
     ClimateEntityFeature,
     HVACMode,
 )
-from homeassistant.const import PRECISION_TENTHS, UnitOfTemperature
+from homeassistant.const import ATTR_MODE, PRECISION_TENTHS, UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -38,11 +38,10 @@ from homeassistant.util import dt as dt_util
 
 from . import EVOHOME_KEY
 from .const import (
-    ATTR_DURATION_DAYS,
-    ATTR_DURATION_HOURS,
+    ATTR_DURATION,
     ATTR_DURATION_UNTIL,
-    ATTR_SYSTEM_MODE,
-    ATTR_ZONE_TEMP,
+    ATTR_PERIOD,
+    ATTR_SETPOINT,
     EvoService,
 )
 from .coordinator import EvoDataUpdateCoordinator
@@ -180,7 +179,7 @@ class EvoZone(EvoChild, EvoClimateEntity):
             return
 
         # otherwise it is EvoService.SET_ZONE_OVERRIDE
-        temperature = max(min(data[ATTR_ZONE_TEMP], self.max_temp), self.min_temp)
+        temperature = max(min(data[ATTR_SETPOINT], self.max_temp), self.min_temp)
 
         if ATTR_DURATION_UNTIL in data:
             duration: timedelta = data[ATTR_DURATION_UNTIL]
@@ -349,16 +348,16 @@ class EvoController(EvoClimateEntity):
         Data validation is not required, it will have been done upstream.
         """
         if service == EvoService.SET_SYSTEM_MODE:
-            mode = data[ATTR_SYSTEM_MODE]
+            mode = data[ATTR_MODE]
         else:  # otherwise it is EvoService.RESET_SYSTEM
             mode = EvoSystemMode.AUTO_WITH_RESET
 
-        if ATTR_DURATION_DAYS in data:
+        if ATTR_PERIOD in data:
             until = dt_util.start_of_local_day()
-            until += data[ATTR_DURATION_DAYS]
+            until += data[ATTR_PERIOD]
 
-        elif ATTR_DURATION_HOURS in data:
-            until = dt_util.now() + data[ATTR_DURATION_HOURS]
+        elif ATTR_DURATION in data:
+            until = dt_util.now() + data[ATTR_DURATION]
 
         else:
             until = None

homeassistant/components/evohome/const.py

@@ -18,11 +18,10 @@ USER_DATA: Final = "user_data"
 SCAN_INTERVAL_DEFAULT: Final = timedelta(seconds=300)
 SCAN_INTERVAL_MINIMUM: Final = timedelta(seconds=60)
 
-ATTR_SYSTEM_MODE: Final = "mode"
-ATTR_DURATION_DAYS: Final = "period"
-ATTR_DURATION_HOURS: Final = "duration"
+ATTR_PERIOD: Final = "period"  # number of days
+ATTR_DURATION: Final = "duration"  # number of minutes, <24h
 
-ATTR_ZONE_TEMP: Final = "setpoint"
+ATTR_SETPOINT: Final = "setpoint"
 ATTR_DURATION_UNTIL: Final = "duration"
 
 

homeassistant/components/ezviz/camera.py

@@ -141,11 +141,6 @@ class EzvizCamera(EzvizEntity, Camera):
         if camera_password:
             self._attr_supported_features = CameraEntityFeature.STREAM
 
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return self.data["status"] != 2
-
     @property
     def is_on(self) -> bool:
         """Return true if on."""

homeassistant/components/ezviz/entity.py

@@ -42,6 +42,11 @@ class EzvizEntity(CoordinatorEntity[EzvizDataUpdateCoordinator], Entity):
         """Return coordinator data for this entity."""
         return self.coordinator.data[self._serial]
 
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return self.data["status"] != 2
+
 
 class EzvizBaseEntity(Entity):
     """Generic entity for EZVIZ individual poll entities."""
@@ -72,3 +77,8 @@ class EzvizBaseEntity(Entity):
     def data(self) -> dict[str, Any]:
         """Return coordinator data for this entity."""
         return self.coordinator.data[self._serial]
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return self.data["status"] != 2

homeassistant/components/ezviz/image.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import logging
 
+from propcache.api import cached_property
 from pyezviz.exceptions import PyEzvizError
 from pyezviz.utils import decrypt_image
 
@@ -62,6 +63,11 @@ class EzvizLastMotion(EzvizEntity, ImageEntity):
             else None
         )
 
+    @cached_property
+    def available(self) -> bool:
+        """Entity gets data from ezviz API so always available."""
+        return True
+
     async def _async_load_image_from_url(self, url: str) -> Image | None:
         """Load an image by url."""
         if response := await self._fetch_url(url):

homeassistant/components/flexit_bacnet/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/flexit_bacnet",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "quality_scale": "bronze",
+  "quality_scale": "silver",
   "requirements": ["flexit_bacnet==2.2.3"]
 }

homeassistant/components/fritzbox/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["pyfritzhome"],
-  "requirements": ["pyfritzhome==0.6.15"],
+  "requirements": ["pyfritzhome==0.6.17"],
   "ssdp": [
     {
       "st": "urn:schemas-upnp-org:device:fritzbox:1"

homeassistant/components/frontend/manifest.json

@@ -1,7 +1,6 @@
 {
   "domain": "frontend",
   "name": "Home Assistant Frontend",
-  "after_dependencies": ["backup"],
   "codeowners": ["@home-assistant/frontend"],
   "dependencies": [
     "api",
@@ -21,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20250214.0"]
+  "requirements": ["home-assistant-frontend==20250221.0"]
 }

homeassistant/components/google_drive/__init__.py

@@ -7,7 +7,7 @@ from collections.abc import Callable
 from google_drive_api.exceptions import GoogleDriveApiError
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import instance_id
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -49,7 +49,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: GoogleDriveConfigEntry)
     except GoogleDriveApiError as err:
         raise ConfigEntryNotReady from err
 
-    _async_notify_backup_listeners_soon(hass)
+    def async_notify_backup_listeners() -> None:
+        for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
+            listener()
+
+    entry.async_on_unload(entry.async_on_state_change(async_notify_backup_listeners))
 
     return True
 
@@ -58,15 +62,4 @@ async def async_unload_entry(
     hass: HomeAssistant, entry: GoogleDriveConfigEntry
 ) -> bool:
     """Unload a config entry."""
-    _async_notify_backup_listeners_soon(hass)
     return True
-
-
-def _async_notify_backup_listeners(hass: HomeAssistant) -> None:
-    for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
-        listener()
-
-
-@callback
-def _async_notify_backup_listeners_soon(hass: HomeAssistant) -> None:
-    hass.loop.call_soon(_async_notify_backup_listeners, hass)

homeassistant/components/google_generative_ai_conversation/__init__.py

@@ -2,14 +2,11 @@
 
 from __future__ import annotations
 
-import mimetypes
 from pathlib import Path
 
-from google.ai import generativelanguage_v1beta
-from google.api_core.client_options import ClientOptions
-from google.api_core.exceptions import ClientError, DeadlineExceeded, GoogleAPIError
-import google.generativeai as genai
-import google.generativeai.types as genai_types
+from google import genai  # type: ignore[attr-defined]
+from google.genai.errors import APIError, ClientError
+from requests.exceptions import Timeout
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
@@ -27,59 +24,86 @@ from homeassistant.exceptions import (
     HomeAssistantError,
 )
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_CHAT_MODEL, CONF_PROMPT, DOMAIN, RECOMMENDED_CHAT_MODEL
+from .const import (
+    CONF_CHAT_MODEL,
+    CONF_PROMPT,
+    DOMAIN,
+    RECOMMENDED_CHAT_MODEL,
+    TIMEOUT_MILLIS,
+)
 
 SERVICE_GENERATE_CONTENT = "generate_content"
 CONF_IMAGE_FILENAME = "image_filename"
+CONF_FILENAMES = "filenames"
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = (Platform.CONVERSATION,)
 
+type GoogleGenerativeAIConfigEntry = ConfigEntry[genai.Client]
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Google Generative AI Conversation."""
 
     async def generate_content(call: ServiceCall) -> ServiceResponse:
         """Generate content from text and optionally images."""
-        prompt_parts = [call.data[CONF_PROMPT]]
-        image_filenames = call.data[CONF_IMAGE_FILENAME]
-        for image_filename in image_filenames:
-            if not hass.config.is_allowed_path(image_filename):
-                raise HomeAssistantError(
-                    f"Cannot read `{image_filename}`, no access to path; "
-                    "`allowlist_external_dirs` may need to be adjusted in "
-                    "`configuration.yaml`"
-                )
-            if not Path(image_filename).exists():
-                raise HomeAssistantError(f"`{image_filename}` does not exist")
-            mime_type, _ = mimetypes.guess_type(image_filename)
-            if mime_type is None or not mime_type.startswith("image"):
-                raise HomeAssistantError(f"`{image_filename}` is not an image")
-            prompt_parts.append(
-                {
-                    "mime_type": mime_type,
-                    "data": await hass.async_add_executor_job(
-                        Path(image_filename).read_bytes
-                    ),
-                }
+
+        if call.data[CONF_IMAGE_FILENAME]:
+            # Deprecated in 2025.3, to remove in 2025.9
+            async_create_issue(
+                hass,
+                DOMAIN,
+                "deprecated_image_filename_parameter",
+                breaks_in_ha_version="2025.9.0",
+                is_fixable=False,
+                severity=IssueSeverity.WARNING,
+                translation_key="deprecated_image_filename_parameter",
             )
 
-        model = genai.GenerativeModel(model_name=RECOMMENDED_CHAT_MODEL)
+        prompt_parts = [call.data[CONF_PROMPT]]
+
+        config_entry: GoogleGenerativeAIConfigEntry = hass.config_entries.async_entries(
+            DOMAIN
+        )[0]
+
+        client = config_entry.runtime_data
+
+        def append_files_to_prompt():
+            image_filenames = call.data[CONF_IMAGE_FILENAME]
+            filenames = call.data[CONF_FILENAMES]
+            for filename in set(image_filenames + filenames):
+                if not hass.config.is_allowed_path(filename):
+                    raise HomeAssistantError(
+                        f"Cannot read `{filename}`, no access to path; "
+                        "`allowlist_external_dirs` may need to be adjusted in "
+                        "`configuration.yaml`"
+                    )
+                if not Path(filename).exists():
+                    raise HomeAssistantError(f"`{filename}` does not exist")
+                prompt_parts.append(client.files.upload(file=filename))
+
+        await hass.async_add_executor_job(append_files_to_prompt)
 
         try:
-            response = await model.generate_content_async(prompt_parts)
+            response = await client.aio.models.generate_content(
+                model=RECOMMENDED_CHAT_MODEL, contents=prompt_parts
+            )
         except (
-            GoogleAPIError,
+            APIError,
             ValueError,
-            genai_types.BlockedPromptException,
-            genai_types.StopCandidateException,
         ) as err:
             raise HomeAssistantError(f"Error generating content: {err}") from err
 
-        if not response.parts:
-            raise HomeAssistantError("Error generating content")
+        if response.prompt_feedback:
+            raise HomeAssistantError(
+                f"Error generating content due to content violations, reason: {response.prompt_feedback.block_reason_message}"
+            )
+
+        if not response.candidates[0].content.parts:
+            raise HomeAssistantError("Unknown error generating content")
 
         return {"text": response.text}
 
@@ -93,6 +117,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                 vol.Optional(CONF_IMAGE_FILENAME, default=[]): vol.All(
                     cv.ensure_list, [cv.string]
                 ),
+                vol.Optional(CONF_FILENAMES, default=[]): vol.All(
+                    cv.ensure_list, [cv.string]
+                ),
             }
         ),
         supports_response=SupportsResponse.ONLY,
@@ -100,30 +127,34 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(
+    hass: HomeAssistant, entry: GoogleGenerativeAIConfigEntry
+) -> bool:
     """Set up Google Generative AI Conversation from a config entry."""
-    genai.configure(api_key=entry.data[CONF_API_KEY])
 
     try:
-        client = generativelanguage_v1beta.ModelServiceAsyncClient(
-            client_options=ClientOptions(api_key=entry.data[CONF_API_KEY])
+        client = genai.Client(api_key=entry.data[CONF_API_KEY])
+        await client.aio.models.get(
+            model=entry.options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL),
+            config={"http_options": {"timeout": TIMEOUT_MILLIS}},
         )
-        await client.get_model(
-            name=entry.options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL), timeout=5.0
-        )
-    except (GoogleAPIError, ValueError) as err:
-        if isinstance(err, ClientError) and err.reason == "API_KEY_INVALID":
-            raise ConfigEntryAuthFailed(err) from err
-        if isinstance(err, DeadlineExceeded):
+    except (APIError, Timeout) as err:
+        if isinstance(err, ClientError) and "API_KEY_INVALID" in str(err):
+            raise ConfigEntryAuthFailed(err.message) from err
+        if isinstance(err, Timeout):
             raise ConfigEntryNotReady(err) from err
         raise ConfigEntryError(err) from err
+    else:
+        entry.runtime_data = client
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, entry: GoogleGenerativeAIConfigEntry
+) -> bool:
     """Unload GoogleGenerativeAI."""
     if not await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
         return False

homeassistant/components/google_generative_ai_conversation/config_flow.py

@@ -3,15 +3,13 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from functools import partial
 import logging
 from types import MappingProxyType
 from typing import Any
 
-from google.ai import generativelanguage_v1beta
-from google.api_core.client_options import ClientOptions
-from google.api_core.exceptions import ClientError, GoogleAPIError
-import google.generativeai as genai
+from google import genai  # type: ignore[attr-defined]
+from google.genai.errors import APIError, ClientError
+from requests.exceptions import Timeout
 import voluptuous as vol
 
 from homeassistant.config_entries import (
@@ -53,6 +51,7 @@ from .const import (
     RECOMMENDED_TEMPERATURE,
     RECOMMENDED_TOP_K,
     RECOMMENDED_TOP_P,
+    TIMEOUT_MILLIS,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -70,15 +69,20 @@ RECOMMENDED_OPTIONS = {
 }
 
 
-async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
+async def validate_input(data: dict[str, Any]) -> None:
     """Validate the user input allows us to connect.
 
     Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
     """
-    client = generativelanguage_v1beta.ModelServiceAsyncClient(
-        client_options=ClientOptions(api_key=data[CONF_API_KEY])
+    client = genai.Client(api_key=data[CONF_API_KEY])
+    await client.aio.models.list(
+        config={
+            "http_options": {
+                "timeout": TIMEOUT_MILLIS,
+            },
+            "query_base": True,
+        }
     )
-    await client.list_models(timeout=5.0)
 
 
 class GoogleGenerativeAIConfigFlow(ConfigFlow, domain=DOMAIN):
@@ -93,9 +97,9 @@ class GoogleGenerativeAIConfigFlow(ConfigFlow, domain=DOMAIN):
         errors: dict[str, str] = {}
         if user_input is not None:
             try:
-                await validate_input(self.hass, user_input)
-            except GoogleAPIError as err:
-                if isinstance(err, ClientError) and err.reason == "API_KEY_INVALID":
+                await validate_input(user_input)
+            except (APIError, Timeout) as err:
+                if isinstance(err, ClientError) and "API_KEY_INVALID" in str(err):
                     errors["base"] = "invalid_auth"
                 else:
                     errors["base"] = "cannot_connect"
@@ -166,6 +170,7 @@ class GoogleGenerativeAIOptionsFlow(OptionsFlow):
         self.last_rendered_recommended = config_entry.options.get(
             CONF_RECOMMENDED, False
         )
+        self._genai_client = config_entry.runtime_data
 
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
@@ -188,7 +193,9 @@ class GoogleGenerativeAIOptionsFlow(OptionsFlow):
                 CONF_LLM_HASS_API: user_input[CONF_LLM_HASS_API],
             }
 
-        schema = await google_generative_ai_config_option_schema(self.hass, options)
+        schema = await google_generative_ai_config_option_schema(
+            self.hass, options, self._genai_client
+        )
         return self.async_show_form(
             step_id="init",
             data_schema=vol.Schema(schema),
@@ -198,6 +205,7 @@ class GoogleGenerativeAIOptionsFlow(OptionsFlow):
 async def google_generative_ai_config_option_schema(
     hass: HomeAssistant,
     options: dict[str, Any] | MappingProxyType[str, Any],
+    genai_client: genai.Client,
 ) -> dict:
     """Return a schema for Google Generative AI completion options."""
     hass_apis: list[SelectOptionDict] = [
@@ -236,18 +244,21 @@ async def google_generative_ai_config_option_schema(
     if options.get(CONF_RECOMMENDED):
         return schema
 
-    api_models = await hass.async_add_executor_job(partial(genai.list_models))
-
+    api_models_pager = await genai_client.aio.models.list(config={"query_base": True})
+    api_models = [api_model async for api_model in api_models_pager]
     models = [
         SelectOptionDict(
             label=api_model.display_name,
             value=api_model.name,
         )
-        for api_model in sorted(api_models, key=lambda x: x.display_name)
+        for api_model in sorted(api_models, key=lambda x: x.display_name or "")
         if (
             api_model.name != "models/gemini-1.0-pro"  # duplicate of gemini-pro
+            and api_model.display_name
+            and api_model.name
+            and api_model.supported_actions
             and "vision" not in api_model.name
-            and "generateContent" in api_model.supported_generation_methods
+            and "generateContent" in api_model.supported_actions
         )
     ]
 

homeassistant/components/google_generative_ai_conversation/const.py

@@ -22,3 +22,5 @@ CONF_HATE_BLOCK_THRESHOLD = "hate_block_threshold"
 CONF_SEXUAL_BLOCK_THRESHOLD = "sexual_block_threshold"
 CONF_DANGEROUS_BLOCK_THRESHOLD = "dangerous_block_threshold"
 RECOMMENDED_HARM_BLOCK_THRESHOLD = "BLOCK_MEDIUM_AND_ABOVE"
+
+TIMEOUT_MILLIS = 10000

homeassistant/components/google_generative_ai_conversation/conversation.py

@@ -6,11 +6,18 @@ import codecs
 from collections.abc import Callable
 from typing import Any, Literal, cast
 
-from google.api_core.exceptions import GoogleAPIError
-import google.generativeai as genai
-from google.generativeai import protos
-import google.generativeai.types as genai_types
-from google.protobuf.json_format import MessageToDict
+from google.genai.errors import APIError
+from google.genai.types import (
+    AutomaticFunctionCallingConfig,
+    Content,
+    FunctionDeclaration,
+    GenerateContentConfig,
+    HarmCategory,
+    Part,
+    SafetySetting,
+    Schema,
+    Tool,
+)
 from voluptuous_openapi import convert
 
 from homeassistant.components import assist_pipeline, conversation
@@ -57,21 +64,40 @@ async def async_setup_entry(
 
 
 SUPPORTED_SCHEMA_KEYS = {
-    "type",
-    "format",
-    "description",
+    "min_items",
+    "example",
+    "property_ordering",
+    "pattern",
+    "minimum",
+    "default",
+    "any_of",
+    "max_length",
+    "title",
+    "min_properties",
+    "min_length",
+    "max_items",
+    "maximum",
     "nullable",
+    "max_properties",
+    "type",
+    "description",
     "enum",
+    "format",
     "items",
     "properties",
     "required",
 }
 
 
-def _format_schema(schema: dict[str, Any]) -> dict[str, Any]:
-    """Format the schema to protobuf."""
-    if (subschemas := schema.get("anyOf")) or (subschemas := schema.get("allOf")):
-        for subschema in subschemas:  # Gemini API does not support anyOf and allOf keys
+def _camel_to_snake(name: str) -> str:
+    """Convert camel case to snake case."""
+    return "".join(["_" + c.lower() if c.isupper() else c for c in name]).lstrip("_")
+
+
+def _format_schema(schema: dict[str, Any]) -> Schema:
+    """Format the schema to be compatible with Gemini API."""
+    if subschemas := schema.get("allOf"):
+        for subschema in subschemas:  # Gemini API does not support allOf keys
             if "type" in subschema:  # Fallback to first subschema with 'type' field
                 return _format_schema(subschema)
         return _format_schema(
@@ -80,42 +106,38 @@ def _format_schema(schema: dict[str, Any]) -> dict[str, Any]:
 
     result = {}
     for key, val in schema.items():
+        key = _camel_to_snake(key)
         if key not in SUPPORTED_SCHEMA_KEYS:
             continue
+        if key == "any_of":
+            val = [_format_schema(subschema) for subschema in val]
         if key == "type":
-            key = "type_"
             val = val.upper()
-        elif key == "format":
-            if schema.get("type") == "string" and val != "enum":
-                continue
-            if schema.get("type") not in ("number", "integer", "string"):
-                continue
-            key = "format_"
-        elif key == "items":
+        if key == "items":
             val = _format_schema(val)
         elif key == "properties":
             val = {k: _format_schema(v) for k, v in val.items()}
         result[key] = val
 
-    if result.get("enum") and result.get("type_") != "STRING":
+    if result.get("enum") and result.get("type") != "STRING":
         # enum is only allowed for STRING type. This is safe as long as the schema
         # contains vol.Coerce for the respective type, for example:
         # vol.All(vol.Coerce(int), vol.In([1, 2, 3]))
-        result["type_"] = "STRING"
+        result["type"] = "STRING"
         result["enum"] = [str(item) for item in result["enum"]]
 
-    if result.get("type_") == "OBJECT" and not result.get("properties"):
+    if result.get("type") == "OBJECT" and not result.get("properties"):
         # An object with undefined properties is not supported by Gemini API.
         # Fallback to JSON string. This will probably fail for most tools that want it,
         # but we don't have a better fallback strategy so far.
-        result["properties"] = {"json": {"type_": "STRING"}}
+        result["properties"] = {"json": {"type": "STRING"}}
         result["required"] = []
-    return result
+    return cast(Schema, result)
 
 
 def _format_tool(
     tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
-) -> dict[str, Any]:
+) -> Tool:
     """Format tool specification."""
 
     if tool.parameters.schema:
@@ -125,16 +147,14 @@ def _format_tool(
     else:
         parameters = None
 
-    return protos.Tool(
-        {
-            "function_declarations": [
-                {
-                    "name": tool.name,
-                    "description": tool.description,
-                    "parameters": parameters,
-                }
-            ]
-        }
+    return Tool(
+        function_declarations=[
+            FunctionDeclaration(
+                name=tool.name,
+                description=tool.description,
+                parameters=parameters,
+            )
+        ]
     )
 
 
@@ -151,14 +171,12 @@ def _escape_decode(value: Any) -> Any:
 
 def _create_google_tool_response_content(
     content: list[conversation.ToolResultContent],
-) -> protos.Content:
+) -> Content:
     """Create a Google tool response content."""
-    return protos.Content(
+    return Content(
         parts=[
-            protos.Part(
-                function_response=protos.FunctionResponse(
-                    name=tool_result.tool_name, response=tool_result.tool_result
-                )
+            Part.from_function_response(
+                name=tool_result.tool_name, response=tool_result.tool_result
             )
             for tool_result in content
         ]
@@ -169,33 +187,36 @@ def _convert_content(
     content: conversation.UserContent
     | conversation.AssistantContent
     | conversation.SystemContent,
-) -> genai_types.ContentDict:
+) -> Content:
     """Convert HA content to Google content."""
     if content.role != "assistant" or not content.tool_calls:  # type: ignore[union-attr]
         role = "model" if content.role == "assistant" else content.role
-        return {"role": role, "parts": content.content}
+        return Content(
+            role=role,
+            parts=[
+                Part.from_text(text=content.content if content.content else ""),
+            ],
+        )
 
     # Handle the Assistant content with tool calls.
     assert type(content) is conversation.AssistantContent
-    parts = []
+    parts: list[Part] = []
 
     if content.content:
-        parts.append(protos.Part(text=content.content))
+        parts.append(Part.from_text(text=content.content))
 
     if content.tool_calls:
         parts.extend(
             [
-                protos.Part(
-                    function_call=protos.FunctionCall(
-                        name=tool_call.tool_name,
-                        args=_escape_decode(tool_call.tool_args),
-                    )
+                Part.from_function_call(
+                    name=tool_call.tool_name,
+                    args=_escape_decode(tool_call.tool_args),
                 )
                 for tool_call in content.tool_calls
             ]
         )
 
-    return protos.Content({"role": "model", "parts": parts})
+    return Content(role="model", parts=parts)
 
 
 class GoogleGenerativeAIConversationEntity(
@@ -209,6 +230,7 @@ class GoogleGenerativeAIConversationEntity(
     def __init__(self, entry: ConfigEntry) -> None:
         """Initialize the agent."""
         self.entry = entry
+        self._genai_client = entry.runtime_data
         self._attr_unique_id = entry.entry_id
         self._attr_device_info = dr.DeviceInfo(
             identifiers={(DOMAIN, entry.entry_id)},
@@ -273,7 +295,7 @@ class GoogleGenerativeAIConversationEntity(
         except conversation.ConverseError as err:
             return err.as_conversation_result()
 
-        tools: list[dict[str, Any]] | None = None
+        tools: list[Tool | Callable[..., Any]] | None = None
         if chat_log.llm_api:
             tools = [
                 _format_tool(tool, chat_log.llm_api.custom_serializer)
@@ -288,13 +310,22 @@ class GoogleGenerativeAIConversationEntity(
             "gemini-1.0" not in model_name and "gemini-pro" not in model_name
         )
 
-        prompt = chat_log.content[0].content  # type: ignore[union-attr]
-        messages: list[genai_types.ContentDict] = []
+        prompt_content = cast(
+            conversation.SystemContent,
+            chat_log.content[0],
+        )
+
+        if prompt_content.content:
+            prompt = prompt_content.content
+        else:
+            raise HomeAssistantError("Invalid prompt content")
+
+        messages: list[Content] = []
 
         # Google groups tool results, we do not. Group them before sending.
         tool_results: list[conversation.ToolResultContent] = []
 
-        for chat_content in chat_log.content[1:]:
+        for chat_content in chat_log.content[1:-1]:
             if chat_content.role == "tool_result":
                 # mypy doesn't like picking a type based on checking shared property 'role'
                 tool_results.append(cast(conversation.ToolResultContent, chat_content))
@@ -317,85 +348,93 @@ class GoogleGenerativeAIConversationEntity(
 
         if tool_results:
             messages.append(_create_google_tool_response_content(tool_results))
-
-        model = genai.GenerativeModel(
-            model_name=model_name,
-            generation_config={
-                "temperature": self.entry.options.get(
-                    CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
+        generateContentConfig = GenerateContentConfig(
+            temperature=self.entry.options.get(
+                CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
+            ),
+            top_k=self.entry.options.get(CONF_TOP_K, RECOMMENDED_TOP_K),
+            top_p=self.entry.options.get(CONF_TOP_P, RECOMMENDED_TOP_P),
+            max_output_tokens=self.entry.options.get(
+                CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS
+            ),
+            safety_settings=[
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+                    threshold=self.entry.options.get(
+                        CONF_HATE_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                    ),
                 ),
-                "top_p": self.entry.options.get(CONF_TOP_P, RECOMMENDED_TOP_P),
-                "top_k": self.entry.options.get(CONF_TOP_K, RECOMMENDED_TOP_K),
-                "max_output_tokens": self.entry.options.get(
-                    CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_HARASSMENT,
+                    threshold=self.entry.options.get(
+                        CONF_HARASSMENT_BLOCK_THRESHOLD,
+                        RECOMMENDED_HARM_BLOCK_THRESHOLD,
+                    ),
                 ),
-            },
-            safety_settings={
-                "HARASSMENT": self.entry.options.get(
-                    CONF_HARASSMENT_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+                    threshold=self.entry.options.get(
+                        CONF_DANGEROUS_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                    ),
                 ),
-                "HATE": self.entry.options.get(
-                    CONF_HATE_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+                    threshold=self.entry.options.get(
+                        CONF_SEXUAL_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                    ),
                 ),
-                "SEXUAL": self.entry.options.get(
-                    CONF_SEXUAL_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
-                ),
-                "DANGEROUS": self.entry.options.get(
-                    CONF_DANGEROUS_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
-                ),
-            },
+            ],
             tools=tools or None,
             system_instruction=prompt if supports_system_instruction else None,
+            automatic_function_calling=AutomaticFunctionCallingConfig(
+                disable=True, maximum_remote_calls=None
+            ),
         )
 
         if not supports_system_instruction:
             messages = [
-                {"role": "user", "parts": prompt},
-                {"role": "model", "parts": "Ok"},
+                Content(role="user", parts=[Part.from_text(text=prompt)]),
+                Content(role="model", parts=[Part.from_text(text="Ok")]),
                 *messages,
             ]
-
-        chat = model.start_chat(history=messages)
-        chat_request = user_input.text
+        chat = self._genai_client.aio.chats.create(
+            model=model_name, history=messages, config=generateContentConfig
+        )
+        chat_request: str | Content = user_input.text
         # To prevent infinite loops, we limit the number of iterations
         for _iteration in range(MAX_TOOL_ITERATIONS):
             try:
-                chat_response = await chat.send_message_async(chat_request)
-            except (
-                GoogleAPIError,
-                ValueError,
-                genai_types.BlockedPromptException,
-                genai_types.StopCandidateException,
-            ) as err:
-                LOGGER.error("Error sending message: %s %s", type(err), err)
+                chat_response = await chat.send_message(message=chat_request)
 
-                if isinstance(
-                    err, genai_types.StopCandidateException
-                ) and "finish_reason: SAFETY\n" in str(err):
-                    error = "The message got blocked by your safety settings"
-                else:
-                    error = (
-                        f"Sorry, I had a problem talking to Google Generative AI: {err}"
+                if chat_response.prompt_feedback:
+                    raise HomeAssistantError(
+                        f"The message got blocked due to content violations, reason: {chat_response.prompt_feedback.block_reason_message}"
                     )
 
+            except (
+                APIError,
+                ValueError,
+            ) as err:
+                LOGGER.error("Error sending message: %s %s", type(err), err)
+                error = f"Sorry, I had a problem talking to Google Generative AI: {err}"
                 raise HomeAssistantError(error) from err
 
-            LOGGER.debug("Response: %s", chat_response.parts)
-            if not chat_response.parts:
+            response_parts = chat_response.candidates[0].content.parts
+            if not response_parts:
                 raise HomeAssistantError(
                     "Sorry, I had a problem getting a response from Google Generative AI."
                 )
             content = " ".join(
-                [part.text.strip() for part in chat_response.parts if part.text]
+                [part.text.strip() for part in response_parts if part.text]
             )
 
             tool_calls = []
-            for part in chat_response.parts:
+            for part in response_parts:
                 if not part.function_call:
                     continue
-                tool_call = MessageToDict(part.function_call._pb)  # noqa: SLF001
-                tool_name = tool_call["name"]
-                tool_args = _escape_decode(tool_call["args"])
+                tool_call = part.function_call
+                tool_name = tool_call.name
+                tool_args = _escape_decode(tool_call.args)
                 tool_calls.append(
                     llm.ToolInput(tool_name=tool_name, tool_args=tool_args)
                 )
@@ -418,7 +457,7 @@ class GoogleGenerativeAIConversationEntity(
 
         response = intent.IntentResponse(language=user_input.language)
         response.async_set_speech(
-            " ".join([part.text.strip() for part in chat_response.parts if part.text])
+            " ".join([part.text.strip() for part in response_parts if part.text])
         )
         return conversation.ConversationResult(
             response=response, conversation_id=chat_log.conversation_id

homeassistant/components/google_generative_ai_conversation/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/google_generative_ai_conversation",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["google-generativeai==0.8.2"]
+  "requirements": ["google-genai==1.1.0"]
 }

homeassistant/components/google_generative_ai_conversation/services.yaml

@@ -9,3 +9,8 @@ generate_content:
       required: false
       selector:
         object:
+    filenames:
+      required: false
+      selector:
+        text:
+          multiple: true

homeassistant/components/google_generative_ai_conversation/strings.json

@@ -56,10 +56,21 @@
         },
         "image_filename": {
           "name": "Image filename",
-          "description": "Images",
+          "description": "Deprecated. Use filenames instead.",
+          "example": "/config/www/image.jpg"
+        },
+        "filenames": {
+          "name": "Attachment filenames",
+          "description": "Attachments to add to the prompt (images, PDFs, etc)",
           "example": "/config/www/image.jpg"
         }
       }
     }
+  },
+  "issues": {
+    "deprecated_image_filename_parameter": {
+      "title": "Deprecated 'image_filename' parameter",
+      "description": "The 'image_filename' parameter in Google Generative AI actions is deprecated. Please edit scripts and automations to use 'filenames' intead."
+    }
   }
 }

homeassistant/components/govee_light_local/coordinator.py

@@ -89,6 +89,10 @@ class GoveeLocalApiCoordinator(DataUpdateCoordinator[list[GoveeDevice]]):
         """Set light color in kelvin."""
         await device.set_temperature(temperature)
 
+    async def set_scene(self, device: GoveeController, scene: str) -> None:
+        """Set light scene."""
+        await device.set_scene(scene)
+
     @property
     def devices(self) -> list[GoveeDevice]:
         """Return a list of discovered Govee devices."""

homeassistant/components/govee_light_local/light.py

@@ -10,9 +10,11 @@ from govee_local_api import GoveeDevice, GoveeLightFeatures
 from homeassistant.components.light import (
     ATTR_BRIGHTNESS,
     ATTR_COLOR_TEMP_KELVIN,
+    ATTR_EFFECT,
     ATTR_RGB_COLOR,
     ColorMode,
     LightEntity,
+    LightEntityFeature,
     filter_supported_color_modes,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -25,6 +27,8 @@ from .coordinator import GoveeLocalApiCoordinator, GoveeLocalConfigEntry
 
 _LOGGER = logging.getLogger(__name__)
 
+_NONE_SCENE = "none"
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -50,10 +54,22 @@ async def async_setup_entry(
 class GoveeLight(CoordinatorEntity[GoveeLocalApiCoordinator], LightEntity):
     """Govee Light."""
 
+    _attr_translation_key = "govee_light"
     _attr_has_entity_name = True
     _attr_name = None
     _attr_supported_color_modes: set[ColorMode]
     _fixed_color_mode: ColorMode | None = None
+    _attr_effect_list: list[str] | None = None
+    _attr_effect: str | None = None
+    _attr_supported_features: LightEntityFeature = LightEntityFeature(0)
+    _last_color_state: (
+        tuple[
+            ColorMode | str | None,
+            int | None,
+            tuple[int, int, int] | tuple[int | None] | None,
+        ]
+        | None
+    ) = None
 
     def __init__(
         self,
@@ -80,6 +96,13 @@ class GoveeLight(CoordinatorEntity[GoveeLocalApiCoordinator], LightEntity):
             if GoveeLightFeatures.BRIGHTNESS & capabilities.features:
                 color_modes.add(ColorMode.BRIGHTNESS)
 
+            if (
+                GoveeLightFeatures.SCENES & capabilities.features
+                and capabilities.scenes
+            ):
+                self._attr_supported_features = LightEntityFeature.EFFECT
+                self._attr_effect_list = [_NONE_SCENE, *capabilities.scenes.keys()]
+
         self._attr_supported_color_modes = filter_supported_color_modes(color_modes)
         if len(self._attr_supported_color_modes) == 1:
             # If the light supports only a single color mode, set it now
@@ -143,12 +166,27 @@ class GoveeLight(CoordinatorEntity[GoveeLocalApiCoordinator], LightEntity):
 
         if ATTR_RGB_COLOR in kwargs:
             self._attr_color_mode = ColorMode.RGB
+            self._attr_effect = None
+            self._last_color_state = None
             red, green, blue = kwargs[ATTR_RGB_COLOR]
             await self.coordinator.set_rgb_color(self._device, red, green, blue)
         elif ATTR_COLOR_TEMP_KELVIN in kwargs:
             self._attr_color_mode = ColorMode.COLOR_TEMP
+            self._attr_effect = None
+            self._last_color_state = None
             temperature: float = kwargs[ATTR_COLOR_TEMP_KELVIN]
             await self.coordinator.set_temperature(self._device, int(temperature))
+        elif ATTR_EFFECT in kwargs:
+            effect = kwargs[ATTR_EFFECT]
+            if effect and self._attr_effect_list and effect in self._attr_effect_list:
+                if effect == _NONE_SCENE:
+                    self._attr_effect = None
+                    await self._restore_last_color_state()
+                else:
+                    self._attr_effect = effect
+                    self._save_last_color_state()
+                    await self.coordinator.set_scene(self._device, effect)
+
         self.async_write_ha_state()
 
     async def async_turn_off(self, **kwargs: Any) -> None:
@@ -159,3 +197,27 @@ class GoveeLight(CoordinatorEntity[GoveeLocalApiCoordinator], LightEntity):
     @callback
     def _update_callback(self, device: GoveeDevice) -> None:
         self.async_write_ha_state()
+
+    def _save_last_color_state(self) -> None:
+        color_mode = self.color_mode
+        self._last_color_state = (
+            color_mode,
+            self.brightness,
+            (self.color_temp_kelvin,)
+            if color_mode == ColorMode.COLOR_TEMP
+            else self.rgb_color,
+        )
+
+    async def _restore_last_color_state(self) -> None:
+        if self._last_color_state:
+            color_mode, brightness, color = self._last_color_state
+            if color:
+                if color_mode == ColorMode.RGB:
+                    await self.coordinator.set_rgb_color(self._device, *color)
+                elif color_mode == ColorMode.COLOR_TEMP:
+                    await self.coordinator.set_temperature(self._device, *color)
+            if brightness:
+                await self.coordinator.set_brightness(
+                    self._device, int((float(brightness) / 255.0) * 100.0)
+                )
+            self._last_color_state = None

homeassistant/components/govee_light_local/strings.json

@@ -9,5 +9,29 @@
       "single_instance_allowed": "[%key:common::config_flow::abort::single_instance_allowed%]",
       "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
     }
+  },
+  "entity": {
+    "light": {
+      "govee_light": {
+        "state_attributes": {
+          "effect": {
+            "state": {
+              "none": "None",
+              "sunrise": "Sunrise",
+              "sunset": "Sunset",
+              "movie": "Movie",
+              "dating": "Dating",
+              "romantic": "Romantic",
+              "twinkle": "Twinkle",
+              "candlelight": "Candlelight",
+              "snowflake": "Snowflake",
+              "energetic": "Energetic",
+              "breathe": "Breathe",
+              "crossing": "Crossing"
+            }
+          }
+        }
+      }
+    }
   }
 }

homeassistant/components/habitica/const.py

@@ -35,6 +35,11 @@ ATTR_TYPE = "type"
 ATTR_PRIORITY = "priority"
 ATTR_TAG = "tag"
 ATTR_KEYWORD = "keyword"
+ATTR_REMOVE_TAG = "remove_tag"
+ATTR_ALIAS = "alias"
+ATTR_PRIORITY = "priority"
+ATTR_COST = "cost"
+ATTR_NOTES = "notes"
 
 SERVICE_CAST_SKILL = "cast_skill"
 SERVICE_START_QUEST = "start_quest"
@@ -50,6 +55,7 @@ SERVICE_SCORE_REWARD = "score_reward"
 
 SERVICE_TRANSFORMATION = "transformation"
 
+SERVICE_UPDATE_REWARD = "update_reward"
 
 DEVELOPER_ID = "4c4ca53f-c059-4ffa-966e-9d29dd405daf"
 X_CLIENT = f"{DEVELOPER_ID} - {APPLICATION_NAME} {__version__}"

homeassistant/components/habitica/icons.json

@@ -217,6 +217,13 @@
       "sections": {
         "filter": "mdi:calendar-filter"
       }
+    },
+    "update_reward": {
+      "service": "mdi:treasure-chest",
+      "sections": {
+        "tag_options": "mdi:tag",
+        "developer_options": "mdi:test-tube"
+      }
     }
   }
 }

homeassistant/components/habitica/services.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 from dataclasses import asdict
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
+from uuid import UUID
 
 from aiohttp import ClientError
 from habiticalib import (
@@ -13,6 +14,7 @@ from habiticalib import (
     NotAuthorizedError,
     NotFoundError,
     Skill,
+    Task,
     TaskData,
     TaskPriority,
     TaskType,
@@ -20,6 +22,7 @@ from habiticalib import (
 )
 import voluptuous as vol
 
+from homeassistant.components.todo import ATTR_RENAME
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import ATTR_NAME, CONF_NAME
 from homeassistant.core import (
@@ -34,14 +37,18 @@ from homeassistant.helpers.issue_registry import IssueSeverity, async_create_iss
 from homeassistant.helpers.selector import ConfigEntrySelector
 
 from .const import (
+    ATTR_ALIAS,
     ATTR_ARGS,
     ATTR_CONFIG_ENTRY,
+    ATTR_COST,
     ATTR_DATA,
     ATTR_DIRECTION,
     ATTR_ITEM,
     ATTR_KEYWORD,
+    ATTR_NOTES,
     ATTR_PATH,
     ATTR_PRIORITY,
+    ATTR_REMOVE_TAG,
     ATTR_SKILL,
     ATTR_TAG,
     ATTR_TARGET,
@@ -61,6 +68,7 @@ from .const import (
     SERVICE_SCORE_REWARD,
     SERVICE_START_QUEST,
     SERVICE_TRANSFORMATION,
+    SERVICE_UPDATE_REWARD,
 )
 from .coordinator import HabiticaConfigEntry
 
@@ -104,6 +112,21 @@ SERVICE_TRANSFORMATION_SCHEMA = vol.Schema(
     }
 )
 
+SERVICE_UPDATE_TASK_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector(),
+        vol.Required(ATTR_TASK): cv.string,
+        vol.Optional(ATTR_RENAME): cv.string,
+        vol.Optional(ATTR_NOTES): cv.string,
+        vol.Optional(ATTR_TAG): vol.All(cv.ensure_list, [str]),
+        vol.Optional(ATTR_REMOVE_TAG): vol.All(cv.ensure_list, [str]),
+        vol.Optional(ATTR_ALIAS): vol.All(
+            cv.string, cv.matches_regex("^[a-zA-Z0-9-_]*$")
+        ),
+        vol.Optional(ATTR_COST): vol.Coerce(float),
+    }
+)
+
 SERVICE_GET_TASKS_SCHEMA = vol.Schema(
     {
         vol.Required(ATTR_CONFIG_ENTRY): ConfigEntrySelector({"integration": DOMAIN}),
@@ -516,6 +539,130 @@ def async_setup_services(hass: HomeAssistant) -> None:  # noqa: C901
 
         return result
 
+    async def update_task(call: ServiceCall) -> ServiceResponse:
+        """Update task action."""
+        entry = get_config_entry(hass, call.data[ATTR_CONFIG_ENTRY])
+        coordinator = entry.runtime_data
+        await coordinator.async_refresh()
+
+        try:
+            current_task = next(
+                task
+                for task in coordinator.data.tasks
+                if call.data[ATTR_TASK] in (str(task.id), task.alias, task.text)
+                and task.Type is TaskType.REWARD
+            )
+        except StopIteration as e:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="task_not_found",
+                translation_placeholders={"task": f"'{call.data[ATTR_TASK]}'"},
+            ) from e
+
+        task_id = current_task.id
+        if TYPE_CHECKING:
+            assert task_id
+        data = Task()
+
+        if rename := call.data.get(ATTR_RENAME):
+            data["text"] = rename
+
+        if (notes := call.data.get(ATTR_NOTES)) is not None:
+            data["notes"] = notes
+
+        tags = cast(list[str], call.data.get(ATTR_TAG))
+        remove_tags = cast(list[str], call.data.get(ATTR_REMOVE_TAG))
+
+        if tags or remove_tags:
+            update_tags = set(current_task.tags)
+            user_tags = {
+                tag.name.lower(): tag.id
+                for tag in coordinator.data.user.tags
+                if tag.id and tag.name
+            }
+
+            if tags:
+                # Creates new tag if it doesn't exist
+                async def create_tag(tag_name: str) -> UUID:
+                    tag_id = (await coordinator.habitica.create_tag(tag_name)).data.id
+                    if TYPE_CHECKING:
+                        assert tag_id
+                    return tag_id
+
+                try:
+                    update_tags.update(
+                        {
+                            user_tags.get(tag_name.lower())
+                            or (await create_tag(tag_name))
+                            for tag_name in tags
+                        }
+                    )
+                except TooManyRequestsError as e:
+                    raise HomeAssistantError(
+                        translation_domain=DOMAIN,
+                        translation_key="setup_rate_limit_exception",
+                        translation_placeholders={"retry_after": str(e.retry_after)},
+                    ) from e
+                except HabiticaException as e:
+                    raise HomeAssistantError(
+                        translation_domain=DOMAIN,
+                        translation_key="service_call_exception",
+                        translation_placeholders={"reason": str(e.error.message)},
+                    ) from e
+                except ClientError as e:
+                    raise HomeAssistantError(
+                        translation_domain=DOMAIN,
+                        translation_key="service_call_exception",
+                        translation_placeholders={"reason": str(e)},
+                    ) from e
+
+            if remove_tags:
+                update_tags.difference_update(
+                    {
+                        user_tags[tag_name.lower()]
+                        for tag_name in remove_tags
+                        if tag_name.lower() in user_tags
+                    }
+                )
+
+            data["tags"] = list(update_tags)
+
+        if (alias := call.data.get(ATTR_ALIAS)) is not None:
+            data["alias"] = alias
+
+        if (cost := call.data.get(ATTR_COST)) is not None:
+            data["value"] = cost
+
+        try:
+            response = await coordinator.habitica.update_task(task_id, data)
+        except TooManyRequestsError as e:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="setup_rate_limit_exception",
+                translation_placeholders={"retry_after": str(e.retry_after)},
+            ) from e
+        except HabiticaException as e:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="service_call_exception",
+                translation_placeholders={"reason": str(e.error.message)},
+            ) from e
+        except ClientError as e:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="service_call_exception",
+                translation_placeholders={"reason": str(e)},
+            ) from e
+        else:
+            return response.data.to_dict(omit_none=True)
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_UPDATE_REWARD,
+        update_task,
+        schema=SERVICE_UPDATE_TASK_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
+    )
     hass.services.async_register(
         DOMAIN,
         SERVICE_API_CALL,

homeassistant/components/habitica/services.yaml

@@ -140,3 +140,43 @@ get_tasks:
           required: false
           selector:
             text:
+update_reward:
+  fields:
+    config_entry: *config_entry
+    task: *task
+    rename:
+      selector:
+        text:
+    notes:
+      required: false
+      selector:
+        text:
+          multiline: true
+    cost:
+      required: false
+      selector:
+        number:
+          min: 0
+          step: 0.01
+          unit_of_measurement: "🪙"
+          mode: box
+    tag_options:
+      collapsed: true
+      fields:
+        tag:
+          required: false
+          selector:
+            text:
+              multiple: true
+        remove_tag:
+          required: false
+          selector:
+            text:
+              multiple: true
+    developer_options:
+      collapsed: true
+      fields:
+        alias:
+          required: false
+          selector:
+            text:

homeassistant/components/habitica/strings.json

@@ -7,7 +7,23 @@
     "unit_tasks": "tasks",
     "unit_health_points": "HP",
     "unit_mana_points": "MP",
-    "unit_experience_points": "XP"
+    "unit_experience_points": "XP",
+    "config_entry_description": "Select the Habitica account to update a task.",
+    "task_description": "The name (or task ID) of the task you want to update.",
+    "rename_name": "Rename",
+    "rename_description": "The new title for the Habitica task.",
+    "notes_name": "Update notes",
+    "notes_description": "The new notes for the Habitica task.",
+    "tag_name": "Add tags",
+    "tag_description": "Add tags to the Habitica task. If a tag does not already exist, a new one will be created.",
+    "remove_tag_name": "Remove tags",
+    "remove_tag_description": "Remove tags from the Habitica task.",
+    "alias_name": "Task alias",
+    "alias_description": "A task alias can be used instead of the name or task ID. Only dashes, underscores, and alphanumeric characters are supported. The task alias must be unique among all your tasks.",
+    "developer_options_name": "Advanced settings",
+    "developer_options_description": "Additional features available in developer mode.",
+    "tag_options_name": "Tags",
+    "tag_options_description": "Add or remove tags from a task."
   },
   "config": {
     "abort": {
@@ -457,6 +473,12 @@
     },
     "authentication_failed": {
       "message": "Authentication failed. It looks like your API token has been reset. Please re-authenticate using your new token"
+    },
+    "frequency_not_weekly": {
+      "message": "Unable to update task, weekly repeat settings apply only to weekly recurring dailies."
+    },
+    "frequency_not_monthly": {
+      "message": "Unable to update task, monthly repeat settings apply only to monthly recurring dailies."
     }
   },
   "issues": {
@@ -651,6 +673,54 @@
           "description": "Use the optional filters to narrow the returned tasks."
         }
       }
+    },
+    "update_reward": {
+      "name": "Update a reward",
+      "description": "Updates a specific reward for the selected Habitica character",
+      "fields": {
+        "config_entry": {
+          "name": "[%key:component::habitica::common::config_entry_name%]",
+          "description": "Select the Habitica account to update a reward."
+        },
+        "task": {
+          "name": "[%key:component::habitica::common::task_name%]",
+          "description": "[%key:component::habitica::common::task_description%]"
+        },
+        "rename": {
+          "name": "[%key:component::habitica::common::rename_name%]",
+          "description": "[%key:component::habitica::common::rename_description%]"
+        },
+        "notes": {
+          "name": "[%key:component::habitica::common::notes_name%]",
+          "description": "[%key:component::habitica::common::notes_description%]"
+        },
+        "tag": {
+          "name": "[%key:component::habitica::common::tag_name%]",
+          "description": "[%key:component::habitica::common::tag_description%]"
+        },
+        "remove_tag": {
+          "name": "[%key:component::habitica::common::remove_tag_name%]",
+          "description": "[%key:component::habitica::common::remove_tag_description%]"
+        },
+        "alias": {
+          "name": "[%key:component::habitica::common::alias_name%]",
+          "description": "[%key:component::habitica::common::alias_description%]"
+        },
+        "cost": {
+          "name": "Cost",
+          "description": "Update the cost of a reward."
+        }
+      },
+      "sections": {
+        "tag_options": {
+          "name": "[%key:component::habitica::common::tag_options_name%]",
+          "description": "[%key:component::habitica::common::tag_options_description%]"
+        },
+        "developer_options": {
+          "name": "[%key:component::habitica::common::developer_options_name%]",
+          "description": "[%key:component::habitica::common::developer_options_description%]"
+        }
+      }
     }
   },
   "selector": {

homeassistant/components/habitica/todo.py

@@ -117,19 +117,24 @@ class BaseHabiticaListEntity(HabiticaBase, TodoListEntity):
         """Move an item in the To-do list."""
         if TYPE_CHECKING:
             assert self.todo_items
+        tasks_order = (
+            self.coordinator.data.user.tasksOrder.todos
+            if self.entity_description.key is HabiticaTodoList.TODOS
+            else self.coordinator.data.user.tasksOrder.dailys
+        )
 
         if previous_uid:
-            pos = (
-                self.todo_items.index(
-                    next(item for item in self.todo_items if item.uid == previous_uid)
-                )
-                + 1
-            )
+            pos = tasks_order.index(UUID(previous_uid))
+            if pos < tasks_order.index(UUID(uid)):
+                pos += 1
+
         else:
             pos = 0
 
         try:
-            await self.coordinator.habitica.reorder_task(UUID(uid), pos)
+            tasks_order[:] = (
+                await self.coordinator.habitica.reorder_task(UUID(uid), pos)
+            ).data
         except TooManyRequestsError as e:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
@@ -143,20 +148,6 @@ class BaseHabiticaListEntity(HabiticaBase, TodoListEntity):
                 translation_key=f"move_{self.entity_description.key}_item_failed",
                 translation_placeholders={"pos": str(pos)},
             ) from e
-        else:
-            # move tasks in the coordinator until we have fresh data
-            tasks = self.coordinator.data.tasks
-            new_pos = (
-                tasks.index(
-                    next(task for task in tasks if task.id == UUID(previous_uid))
-                )
-                + 1
-                if previous_uid
-                else 0
-            )
-            old_pos = tasks.index(next(task for task in tasks if task.id == UUID(uid)))
-            tasks.insert(new_pos, tasks.pop(old_pos))
-            await self.coordinator.async_request_refresh()
 
     async def async_update_todo_item(self, item: TodoItem) -> None:
         """Update a Habitica todo."""
@@ -270,7 +261,7 @@ class HabiticaTodosListEntity(BaseHabiticaListEntity):
     def todo_items(self) -> list[TodoItem]:
         """Return the todo items."""
 
-        return [
+        tasks = [
             *(
                 TodoItem(
                     uid=str(task.id),
@@ -287,6 +278,15 @@ class HabiticaTodosListEntity(BaseHabiticaListEntity):
                 if task.Type is TaskType.TODO
             ),
         ]
+        return sorted(
+            tasks,
+            key=lambda task: (
+                float("inf")
+                if (uid := UUID(task.uid))
+                not in (tasks_order := self.coordinator.data.user.tasksOrder.todos)
+                else tasks_order.index(uid)
+            ),
+        )
 
     async def async_create_todo_item(self, item: TodoItem) -> None:
         """Create a Habitica todo."""
@@ -347,7 +347,7 @@ class HabiticaDailiesListEntity(BaseHabiticaListEntity):
         if TYPE_CHECKING:
             assert self.coordinator.data.user.lastCron
 
-        return [
+        tasks = [
             *(
                 TodoItem(
                     uid=str(task.id),
@@ -364,3 +364,12 @@ class HabiticaDailiesListEntity(BaseHabiticaListEntity):
                 if task.Type is TaskType.DAILY
             )
         ]
+        return sorted(
+            tasks,
+            key=lambda task: (
+                float("inf")
+                if (uid := UUID(task.uid))
+                not in (tasks_order := self.coordinator.data.user.tasksOrder.dailys)
+                else tasks_order.index(uid)
+            ),
+        )

homeassistant/components/hassio/backup.py

@@ -45,13 +45,13 @@ from homeassistant.components.backup import (
     RestoreBackupStage,
     RestoreBackupState,
     WrittenBackup,
-    async_get_manager as async_get_backup_manager,
     suggested_filename as suggested_backup_filename,
     suggested_filename_from_name_date,
 )
 from homeassistant.const import __version__ as HAVERSION
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.backup import async_get_manager as async_get_backup_manager
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.util import dt as dt_util
 from homeassistant.util.enum import try_parse_enum
@@ -751,7 +751,7 @@ async def backup_addon_before_update(
 
 async def backup_core_before_update(hass: HomeAssistant) -> None:
     """Prepare for updating core."""
-    backup_manager = async_get_backup_manager(hass)
+    backup_manager = await async_get_backup_manager(hass)
     client = get_supervisor_client(hass)
 
     try:

homeassistant/components/heos/config_flow.py

@@ -102,6 +102,18 @@ async def _validate_auth(
         return True
 
 
+def _get_current_hosts(entry: HeosConfigEntry) -> set[str]:
+    """Get a set of current hosts from the entry."""
+    hosts = set(entry.data[CONF_HOST])
+    if hasattr(entry, "runtime_data"):
+        hosts.update(
+            player.ip_address
+            for player in entry.runtime_data.heos.players.values()
+            if player.ip_address is not None
+        )
+    return hosts
+
+
 class HeosFlowHandler(ConfigFlow, domain=DOMAIN):
     """Define a flow for HEOS."""
 
@@ -125,10 +137,15 @@ class HeosFlowHandler(ConfigFlow, domain=DOMAIN):
         if TYPE_CHECKING:
             assert discovery_info.ssdp_location
 
-        await self.async_set_unique_id(DOMAIN)
-        # Connect to discovered host and get system information
+        entry: HeosConfigEntry | None = await self.async_set_unique_id(DOMAIN)
         hostname = urlparse(discovery_info.ssdp_location).hostname
         assert hostname is not None
+
+        # Abort early when discovered host is part of the current system
+        if entry and hostname in _get_current_hosts(entry):
+            return self.async_abort(reason="single_instance_allowed")
+
+        # Connect to discovered host and get system information
         heos = Heos(HeosOptions(hostname, events=False, heart_beat=False))
         try:
             await heos.connect()
@@ -146,8 +163,23 @@ class HeosFlowHandler(ConfigFlow, domain=DOMAIN):
         # Select the preferred host, if available
         if system_info.preferred_hosts:
             hostname = system_info.preferred_hosts[0].ip_address
-        self._discovered_host = hostname
-        return await self.async_step_confirm_discovery()
+
+        # Move to confirmation when not configured
+        if entry is None:
+            self._discovered_host = hostname
+            return await self.async_step_confirm_discovery()
+
+        # Only update if the configured host isn't part of the discovered hosts to ensure new players that come online don't trigger a reload
+        if entry.data[CONF_HOST] not in [host.ip_address for host in system_info.hosts]:
+            _LOGGER.debug(
+                "Updated host %s to discovered host %s", entry.data[CONF_HOST], hostname
+            )
+            return self.async_update_reload_and_abort(
+                entry,
+                data_updates={CONF_HOST: hostname},
+                reason="reconfigure_successful",
+            )
+        return self.async_abort(reason="single_instance_allowed")
 
     async def async_step_confirm_discovery(
         self, user_input: dict[str, Any] | None = None
@@ -167,6 +199,7 @@ class HeosFlowHandler(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Obtain host and validate connection."""
         await self.async_set_unique_id(DOMAIN)
+        self._abort_if_unique_id_configured(error="single_instance_allowed")
         # Try connecting to host if provided
         errors: dict[str, str] = {}
         host = None

homeassistant/components/heos/manifest.json

@@ -7,9 +7,8 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["pyheos"],
-  "quality_scale": "silver",
+  "quality_scale": "platinum",
   "requirements": ["pyheos==1.0.2"],
-  "single_config_entry": true,
   "ssdp": [
     {
       "st": "urn:schemas-denon-com:device:ACT-Denon:1"

homeassistant/components/heos/quality_scale.yaml

@@ -38,9 +38,7 @@ rules:
   # Gold
   devices: done
   diagnostics: done
-  discovery-update-info:
-    status: todo
-    comment: Explore if this is possible.
+  discovery-update-info: done
   discovery: done
   docs-data-update: done
   docs-examples: done

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.66", "babel==2.15.0"]
+  "requirements": ["holidays==0.67", "babel==2.15.0"]
 }

homeassistant/components/home_connect/__init__.py

@@ -187,6 +187,7 @@ SERVICE_COMMAND_SCHEMA = vol.Schema({vol.Required(ATTR_DEVICE_ID): str})
 
 PLATFORMS = [
     Platform.BINARY_SENSOR,
+    Platform.BUTTON,
     Platform.LIGHT,
     Platform.NUMBER,
     Platform.SELECT,
@@ -202,7 +203,13 @@ async def _get_client_and_ha_id(
     device_registry = dr.async_get(hass)
     device_entry = device_registry.async_get(device_id)
     if device_entry is None:
-        raise ServiceValidationError("Device entry not found for device id")
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="device_entry_not_found",
+            translation_placeholders={
+                "device_id": device_id,
+            },
+        )
     entry: HomeConnectConfigEntry | None = None
     for entry_id in device_entry.config_entries:
         _entry = hass.config_entries.async_get_entry(entry_id)
@@ -212,7 +219,11 @@ async def _get_client_and_ha_id(
             break
     if entry is None:
         raise ServiceValidationError(
-            "Home Connect config entry not found for that device id"
+            translation_domain=DOMAIN,
+            translation_key="config_entry_not_found",
+            translation_placeholders={
+                "device_id": device_id,
+            },
         )
 
     ha_id = next(
@@ -404,6 +415,17 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
         """Execute calls to services executing a command."""
         client, ha_id = await _get_client_and_ha_id(hass, call.data[ATTR_DEVICE_ID])
 
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "deprecated_command_actions",
+            breaks_in_ha_version="2025.9.0",
+            is_fixable=True,
+            is_persistent=True,
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_command_actions",
+        )
+
         try:
             await client.put_command(ha_id, command_key=command_key, value=True)
         except HomeConnectError as err:
@@ -609,6 +631,7 @@ async def async_unload_entry(
 ) -> bool:
     """Unload a config entry."""
     async_delete_issue(hass, DOMAIN, "deprecated_set_program_and_option_actions")
+    async_delete_issue(hass, DOMAIN, "deprecated_command_actions")
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 

homeassistant/components/home_connect/binary_sensor.py

@@ -38,6 +38,8 @@ from .coordinator import (
 )
 from .entity import HomeConnectEntity
 
+PARALLEL_UPDATES = 0
+
 REFRIGERATION_DOOR_BOOLEAN_MAP = {
     REFRIGERATION_STATUS_DOOR_CLOSED: False,
     REFRIGERATION_STATUS_DOOR_OPEN: True,

homeassistant/components/home_connect/button.py

@@ -0,0 +1,162 @@
+"""Provides button entities for Home Connect."""
+
+from aiohomeconnect.model import CommandKey, EventKey
+from aiohomeconnect.model.error import HomeConnectError
+
+from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .common import setup_home_connect_entry
+from .const import APPLIANCES_WITH_PROGRAMS, DOMAIN
+from .coordinator import (
+    HomeConnectApplianceData,
+    HomeConnectConfigEntry,
+    HomeConnectCoordinator,
+)
+from .entity import HomeConnectEntity
+from .utils import get_dict_from_home_connect_error
+
+PARALLEL_UPDATES = 1
+
+
+class HomeConnectCommandButtonEntityDescription(ButtonEntityDescription):
+    """Describes Home Connect button entity."""
+
+    key: CommandKey
+
+
+COMMAND_BUTTONS = (
+    HomeConnectCommandButtonEntityDescription(
+        key=CommandKey.BSH_COMMON_OPEN_DOOR,
+        translation_key="open_door",
+    ),
+    HomeConnectCommandButtonEntityDescription(
+        key=CommandKey.BSH_COMMON_PARTLY_OPEN_DOOR,
+        translation_key="partly_open_door",
+    ),
+    HomeConnectCommandButtonEntityDescription(
+        key=CommandKey.BSH_COMMON_PAUSE_PROGRAM,
+        translation_key="pause_program",
+    ),
+    HomeConnectCommandButtonEntityDescription(
+        key=CommandKey.BSH_COMMON_RESUME_PROGRAM,
+        translation_key="resume_program",
+    ),
+)
+
+
+def _get_entities_for_appliance(
+    entry: HomeConnectConfigEntry,
+    appliance: HomeConnectApplianceData,
+) -> list[HomeConnectEntity]:
+    """Get a list of entities."""
+    entities: list[HomeConnectEntity] = []
+    entities.extend(
+        HomeConnectCommandButtonEntity(entry.runtime_data, appliance, description)
+        for description in COMMAND_BUTTONS
+        if description.key in appliance.commands
+    )
+    if appliance.info.type in APPLIANCES_WITH_PROGRAMS:
+        entities.append(
+            HomeConnectStopProgramButtonEntity(entry.runtime_data, appliance)
+        )
+
+    return entities
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: HomeConnectConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Home Connect button entities."""
+    setup_home_connect_entry(
+        entry,
+        _get_entities_for_appliance,
+        async_add_entities,
+    )
+
+
+class HomeConnectButtonEntity(HomeConnectEntity, ButtonEntity):
+    """Describes Home Connect button entity."""
+
+    entity_description: ButtonEntityDescription
+
+    def __init__(
+        self,
+        coordinator: HomeConnectCoordinator,
+        appliance: HomeConnectApplianceData,
+        desc: ButtonEntityDescription,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(
+            coordinator,
+            appliance,
+            # The entity is subscribed to the appliance connected event,
+            # but it will receive also the disconnected event
+            ButtonEntityDescription(
+                key=EventKey.BSH_COMMON_APPLIANCE_CONNECTED,
+            ),
+        )
+        self.entity_description = desc
+        self.appliance = appliance
+        self.unique_id = f"{appliance.info.ha_id}-{desc.key}"
+
+    def update_native_value(self) -> None:
+        """Set the value of the entity."""
+
+
+class HomeConnectCommandButtonEntity(HomeConnectButtonEntity):
+    """Button entity for Home Connect commands."""
+
+    entity_description: HomeConnectCommandButtonEntityDescription
+
+    async def async_press(self) -> None:
+        """Press the button."""
+        try:
+            await self.coordinator.client.put_command(
+                self.appliance.info.ha_id,
+                command_key=self.entity_description.key,
+                value=True,
+            )
+        except HomeConnectError as error:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="execute_command",
+                translation_placeholders={
+                    **get_dict_from_home_connect_error(error),
+                    "command": self.entity_description.key,
+                },
+            ) from error
+
+
+class HomeConnectStopProgramButtonEntity(HomeConnectButtonEntity):
+    """Button entity for stopping a program."""
+
+    def __init__(
+        self,
+        coordinator: HomeConnectCoordinator,
+        appliance: HomeConnectApplianceData,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(
+            coordinator,
+            appliance,
+            ButtonEntityDescription(
+                key="StopProgram",
+                translation_key="stop_program",
+            ),
+        )
+
+    async def async_press(self) -> None:
+        """Press the button."""
+        try:
+            await self.coordinator.client.stop_program(self.appliance.info.ha_id)
+        except HomeConnectError as error:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="stop_program",
+                translation_placeholders=get_dict_from_home_connect_error(error),
+            ) from error

homeassistant/components/home_connect/common.py

@@ -1,5 +1,6 @@
 """Common callbacks for all Home Connect platforms."""
 
+from collections import defaultdict
 from collections.abc import Callable
 from functools import partial
 from typing import cast
@@ -9,7 +10,32 @@ from aiohomeconnect.model import EventKey
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import HomeConnectApplianceData, HomeConnectConfigEntry
-from .entity import HomeConnectEntity
+from .entity import HomeConnectEntity, HomeConnectOptionEntity
+
+
+def _create_option_entities(
+    entry: HomeConnectConfigEntry,
+    appliance: HomeConnectApplianceData,
+    known_entity_unique_ids: dict[str, str],
+    get_option_entities_for_appliance: Callable[
+        [HomeConnectConfigEntry, HomeConnectApplianceData],
+        list[HomeConnectOptionEntity],
+    ],
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Create the required option entities for the appliances."""
+    option_entities_to_add = [
+        entity
+        for entity in get_option_entities_for_appliance(entry, appliance)
+        if entity.unique_id not in known_entity_unique_ids
+    ]
+    known_entity_unique_ids.update(
+        {
+            cast(str, entity.unique_id): appliance.info.ha_id
+            for entity in option_entities_to_add
+        }
+    )
+    async_add_entities(option_entities_to_add)
 
 
 def _handle_paired_or_connected_appliance(
@@ -18,6 +44,12 @@ def _handle_paired_or_connected_appliance(
     get_entities_for_appliance: Callable[
         [HomeConnectConfigEntry, HomeConnectApplianceData], list[HomeConnectEntity]
     ],
+    get_option_entities_for_appliance: Callable[
+        [HomeConnectConfigEntry, HomeConnectApplianceData],
+        list[HomeConnectOptionEntity],
+    ]
+    | None,
+    changed_options_listener_remove_callbacks: dict[str, list[Callable[[], None]]],
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Handle a new paired appliance or an appliance that has been connected.
@@ -34,6 +66,28 @@ def _handle_paired_or_connected_appliance(
             for entity in get_entities_for_appliance(entry, appliance)
             if entity.unique_id not in known_entity_unique_ids
         ]
+        if get_option_entities_for_appliance:
+            entities_to_add.extend(
+                entity
+                for entity in get_option_entities_for_appliance(entry, appliance)
+                if entity.unique_id not in known_entity_unique_ids
+            )
+            changed_options_listener_remove_callback = (
+                entry.runtime_data.async_add_listener(
+                    partial(
+                        _create_option_entities,
+                        entry,
+                        appliance,
+                        known_entity_unique_ids,
+                        get_option_entities_for_appliance,
+                        async_add_entities,
+                    ),
+                )
+            )
+            entry.async_on_unload(changed_options_listener_remove_callback)
+            changed_options_listener_remove_callbacks[appliance.info.ha_id].append(
+                changed_options_listener_remove_callback
+            )
         known_entity_unique_ids.update(
             {
                 cast(str, entity.unique_id): appliance.info.ha_id
@@ -47,11 +101,17 @@ def _handle_paired_or_connected_appliance(
 def _handle_depaired_appliance(
     entry: HomeConnectConfigEntry,
     known_entity_unique_ids: dict[str, str],
+    changed_options_listener_remove_callbacks: dict[str, list[Callable[[], None]]],
 ) -> None:
     """Handle a removed appliance."""
     for entity_unique_id, appliance_id in known_entity_unique_ids.copy().items():
         if appliance_id not in entry.runtime_data.data:
             known_entity_unique_ids.pop(entity_unique_id, None)
+            if appliance_id in changed_options_listener_remove_callbacks:
+                for listener in changed_options_listener_remove_callbacks.pop(
+                    appliance_id
+                ):
+                    listener()
 
 
 def setup_home_connect_entry(
@@ -60,13 +120,44 @@ def setup_home_connect_entry(
         [HomeConnectConfigEntry, HomeConnectApplianceData], list[HomeConnectEntity]
     ],
     async_add_entities: AddConfigEntryEntitiesCallback,
+    get_option_entities_for_appliance: Callable[
+        [HomeConnectConfigEntry, HomeConnectApplianceData],
+        list[HomeConnectOptionEntity],
+    ]
+    | None = None,
 ) -> None:
     """Set up the callbacks for paired and depaired appliances."""
     known_entity_unique_ids: dict[str, str] = {}
+    changed_options_listener_remove_callbacks: dict[str, list[Callable[[], None]]] = (
+        defaultdict(list)
+    )
 
     entities: list[HomeConnectEntity] = []
     for appliance in entry.runtime_data.data.values():
         entities_to_add = get_entities_for_appliance(entry, appliance)
+        if get_option_entities_for_appliance:
+            entities_to_add.extend(get_option_entities_for_appliance(entry, appliance))
+            for event_key in (
+                EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
+                EventKey.BSH_COMMON_ROOT_SELECTED_PROGRAM,
+            ):
+                changed_options_listener_remove_callback = (
+                    entry.runtime_data.async_add_listener(
+                        partial(
+                            _create_option_entities,
+                            entry,
+                            appliance,
+                            known_entity_unique_ids,
+                            get_option_entities_for_appliance,
+                            async_add_entities,
+                        ),
+                        (appliance.info.ha_id, event_key),
+                    )
+                )
+                entry.async_on_unload(changed_options_listener_remove_callback)
+                changed_options_listener_remove_callbacks[appliance.info.ha_id].append(
+                    changed_options_listener_remove_callback
+                )
         known_entity_unique_ids.update(
             {
                 cast(str, entity.unique_id): appliance.info.ha_id
@@ -83,6 +174,8 @@ def setup_home_connect_entry(
                 entry,
                 known_entity_unique_ids,
                 get_entities_for_appliance,
+                get_option_entities_for_appliance,
+                changed_options_listener_remove_callbacks,
                 async_add_entities,
             ),
             (
@@ -93,7 +186,12 @@ def setup_home_connect_entry(
     )
     entry.async_on_unload(
         entry.runtime_data.async_add_special_listener(
-            partial(_handle_depaired_appliance, entry, known_entity_unique_ids),
+            partial(
+                _handle_depaired_appliance,
+                entry,
+                known_entity_unique_ids,
+                changed_options_listener_remove_callbacks,
+            ),
             (EventKey.BSH_COMMON_APPLIANCE_DEPAIRED,),
         )
     )

homeassistant/components/home_connect/const.py

@@ -87,7 +87,7 @@ PROGRAMS_TRANSLATION_KEYS_MAP = {
     value: key for key, value in TRANSLATION_KEYS_PROGRAMS_MAP.items()
 }
 
-REFERENCE_MAP_ID_OPTIONS = {
+AVAILABLE_MAPS_ENUM = {
     bsh_key_to_translation_key(option): option
     for option in (
         "ConsumerProducts.CleaningRobot.EnumType.AvailableMaps.TempMap",
@@ -305,7 +305,7 @@ PROGRAM_ENUM_OPTIONS = {
     for option_key, options in (
         (
             OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_REFERENCE_MAP_ID,
-            REFERENCE_MAP_ID_OPTIONS,
+            AVAILABLE_MAPS_ENUM,
         ),
         (
             OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_CLEANING_MODE,

homeassistant/components/home_connect/coordinator.py

@@ -7,16 +7,19 @@ from collections import defaultdict
 from collections.abc import Callable
 from dataclasses import dataclass
 import logging
-from typing import Any
+from typing import Any, cast
 
 from aiohomeconnect.client import Client as HomeConnectClient
 from aiohomeconnect.model import (
+    CommandKey,
     Event,
     EventKey,
     EventMessage,
     EventType,
     GetSetting,
     HomeAppliance,
+    OptionKey,
+    ProgramKey,
     SettingKey,
     Status,
     StatusKey,
@@ -28,7 +31,7 @@ from aiohomeconnect.model.error import (
     HomeConnectRequestError,
     UnauthorizedError,
 )
-from aiohomeconnect.model.program import EnumerateProgram
+from aiohomeconnect.model.program import EnumerateProgram, ProgramDefinitionOption
 from propcache.api import cached_property
 
 from homeassistant.config_entries import ConfigEntry
@@ -51,16 +54,21 @@ EVENT_STREAM_RECONNECT_DELAY = 30
 class HomeConnectApplianceData:
     """Class to hold Home Connect appliance data."""
 
+    commands: set[CommandKey]
     events: dict[EventKey, Event]
     info: HomeAppliance
+    options: dict[OptionKey, ProgramDefinitionOption]
     programs: list[EnumerateProgram]
     settings: dict[SettingKey, GetSetting]
     status: dict[StatusKey, Status]
 
     def update(self, other: HomeConnectApplianceData) -> None:
         """Update data with data from other instance."""
+        self.commands.update(other.commands)
         self.events.update(other.events)
         self.info.connected = other.info.connected
+        self.options.clear()
+        self.options.update(other.options)
         self.programs.clear()
         self.programs.extend(other.programs)
         self.settings.update(other.settings)
@@ -172,8 +180,9 @@ class HomeConnectCoordinator(
                             settings = self.data[event_message_ha_id].settings
                             events = self.data[event_message_ha_id].events
                             for event in event_message.data.items:
-                                if event.key in SettingKey:
-                                    setting_key = SettingKey(event.key)
+                                event_key = event.key
+                                if event_key in SettingKey:
+                                    setting_key = SettingKey(event_key)
                                     if setting_key in settings:
                                         settings[setting_key].value = event.value
                                     else:
@@ -183,7 +192,16 @@ class HomeConnectCoordinator(
                                             value=event.value,
                                         )
                                 else:
-                                    events[event.key] = event
+                                    if event_key in (
+                                        EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
+                                        EventKey.BSH_COMMON_ROOT_SELECTED_PROGRAM,
+                                    ):
+                                        await self.update_options(
+                                            event_message_ha_id,
+                                            event_key,
+                                            ProgramKey(cast(str, event.value)),
+                                        )
+                                    events[event_key] = event
                             self._call_event_listener(event_message)
 
                         case EventType.EVENT:
@@ -338,6 +356,7 @@ class HomeConnectCoordinator(
 
         programs = []
         events = {}
+        options = {}
         if appliance.type in APPLIANCES_WITH_PROGRAMS:
             try:
                 all_programs = await self.client.get_all_programs(appliance.ha_id)
@@ -351,15 +370,17 @@ class HomeConnectCoordinator(
                 )
             else:
                 programs.extend(all_programs.programs)
+                current_program_key = None
+                program_options = None
                 for program, event_key in (
-                    (
-                        all_programs.active,
-                        EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
-                    ),
                     (
                         all_programs.selected,
                         EventKey.BSH_COMMON_ROOT_SELECTED_PROGRAM,
                     ),
+                    (
+                        all_programs.active,
+                        EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
+                    ),
                 ):
                     if program and program.key:
                         events[event_key] = Event(
@@ -370,10 +391,41 @@ class HomeConnectCoordinator(
                             "",
                             program.key,
                         )
+                        current_program_key = program.key
+                        program_options = program.options
+                if current_program_key:
+                    options = await self.get_options_definitions(
+                        appliance.ha_id, current_program_key
+                    )
+                    for option in program_options or []:
+                        option_event_key = EventKey(option.key)
+                        events[option_event_key] = Event(
+                            option_event_key,
+                            option.key,
+                            0,
+                            "",
+                            "",
+                            option.value,
+                            option.name,
+                            display_value=option.display_value,
+                            unit=option.unit,
+                        )
+
+        try:
+            commands = {
+                command.key
+                for command in (
+                    await self.client.get_available_commands(appliance.ha_id)
+                ).commands
+            }
+        except HomeConnectError:
+            commands = set()
 
         appliance_data = HomeConnectApplianceData(
+            commands=commands,
             events=events,
             info=appliance,
+            options=options,
             programs=programs,
             settings=settings,
             status=status,
@@ -383,3 +435,48 @@ class HomeConnectCoordinator(
             appliance_data = appliance_data_to_update
 
         return appliance_data
+
+    async def get_options_definitions(
+        self, ha_id: str, program_key: ProgramKey
+    ) -> dict[OptionKey, ProgramDefinitionOption]:
+        """Get options with constraints for appliance."""
+        return {
+            option.key: option
+            for option in (
+                await self.client.get_available_program(ha_id, program_key=program_key)
+            ).options
+            or []
+        }
+
+    async def update_options(
+        self, ha_id: str, event_key: EventKey, program_key: ProgramKey
+    ) -> None:
+        """Update options for appliance."""
+        options = self.data[ha_id].options
+        events = self.data[ha_id].events
+        options_to_notify = options.copy()
+        options.clear()
+        if program_key is not ProgramKey.UNKNOWN:
+            options.update(await self.get_options_definitions(ha_id, program_key))
+
+        for option in options.values():
+            option_value = option.constraints.default if option.constraints else None
+            if option_value is not None:
+                option_event_key = EventKey(option.key)
+                events[option_event_key] = Event(
+                    option_event_key,
+                    option.key.value,
+                    0,
+                    "",
+                    "",
+                    option_value,
+                    option.name,
+                    unit=option.unit,
+                )
+        options_to_notify.update(options)
+        for option_key in options_to_notify:
+            for listener in self.context_listeners.get(
+                (ha_id, EventKey(option_key)),
+                [],
+            ):
+                listener()

homeassistant/components/home_connect/entity.py

@@ -1,17 +1,22 @@
 """Home Connect entity base class."""
 
 from abc import abstractmethod
+import contextlib
 import logging
+from typing import cast
 
-from aiohomeconnect.model import EventKey
+from aiohomeconnect.model import EventKey, OptionKey
+from aiohomeconnect.model.error import ActiveProgramNotSetError, HomeConnectError
 
 from homeassistant.core import callback
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import HomeConnectApplianceData, HomeConnectCoordinator
+from .utils import get_dict_from_home_connect_error
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -60,3 +65,59 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
         return (
             self.appliance.info.connected and self._attr_available and super().available
         )
+
+
+class HomeConnectOptionEntity(HomeConnectEntity):
+    """Class for entities that represents program options."""
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return super().available and self.bsh_key in self.appliance.options
+
+    @property
+    def option_value(self) -> str | int | float | bool | None:
+        """Return the state of the entity."""
+        if event := self.appliance.events.get(EventKey(self.bsh_key)):
+            return event.value
+        return None
+
+    async def async_set_option(self, value: str | float | bool) -> None:
+        """Set an option for the entity."""
+        try:
+            # We try to set the active program option first,
+            # if it fails we try to set the selected program option
+            with contextlib.suppress(ActiveProgramNotSetError):
+                await self.coordinator.client.set_active_program_option(
+                    self.appliance.info.ha_id,
+                    option_key=self.bsh_key,
+                    value=value,
+                )
+                _LOGGER.debug(
+                    "Updated %s for the active program, new state: %s",
+                    self.entity_id,
+                    self.state,
+                )
+                return
+
+            await self.coordinator.client.set_selected_program_option(
+                self.appliance.info.ha_id,
+                option_key=self.bsh_key,
+                value=value,
+            )
+            _LOGGER.debug(
+                "Updated %s for the selected program, new state: %s",
+                self.entity_id,
+                self.state,
+            )
+        except HomeConnectError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="set_option",
+                translation_placeholders=get_dict_from_home_connect_error(err),
+            ) from err
+
+    @property
+    def bsh_key(self) -> OptionKey:
+        """Return the BSH key."""
+        return cast(OptionKey, self.entity_description.key)

homeassistant/components/home_connect/icons.json

@@ -208,6 +208,39 @@
       },
       "door-assistant_freezer": {
         "default": "mdi:door"
+      },
+      "silence_on_demand": {
+        "default": "mdi:volume-mute",
+        "state": {
+          "on": "mdi:volume-mute",
+          "off": "mdi:volume-high"
+        }
+      },
+      "half_load": {
+        "default": "mdi:fraction-one-half"
+      },
+      "hygiene_plus": {
+        "default": "mdi:silverware-clean"
+      },
+      "eco_dry": {
+        "default": "mdi:sprout"
+      },
+      "fast_pre_heat": {
+        "default": "mdi:fire"
+      },
+      "i_dos_1_active": {
+        "default": "mdi:numeric-1-circle"
+      },
+      "i_dos_2_active": {
+        "default": "mdi:numeric-2-circle"
+      }
+    },
+    "time": {
+      "start_in_relative": {
+        "default": "mdi:progress-clock"
+      },
+      "finish_in_relative": {
+        "default": "mdi:progress-clock"
       }
     }
   }

homeassistant/components/home_connect/light.py

@@ -36,6 +36,8 @@ from .utils import get_dict_from_home_connect_error
 
 _LOGGER = logging.getLogger(__name__)
 
+PARALLEL_UPDATES = 1
+
 
 @dataclass(frozen=True, kw_only=True)
 class HomeConnectLightEntityDescription(LightEntityDescription):

homeassistant/components/home_connect/manifest.json

@@ -7,6 +7,6 @@
   "documentation": "https://www.home-assistant.io/integrations/home_connect",
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
-  "requirements": ["aiohomeconnect==0.12.3"],
+  "requirements": ["aiohomeconnect==0.15.0"],
   "single_config_entry": true
 }

homeassistant/components/home_connect/number.py

@@ -3,7 +3,7 @@
 import logging
 from typing import cast
 
-from aiohomeconnect.model import GetSetting, SettingKey
+from aiohomeconnect.model import GetSetting, OptionKey, SettingKey
 from aiohomeconnect.model.error import HomeConnectError
 
 from homeassistant.components.number import (
@@ -11,6 +11,7 @@ from homeassistant.components.number import (
     NumberEntity,
     NumberEntityDescription,
 )
+from homeassistant.const import UnitOfTemperature, UnitOfTime, UnitOfVolume
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -24,11 +25,19 @@ from .const import (
     SVE_TRANSLATION_PLACEHOLDER_VALUE,
 )
 from .coordinator import HomeConnectApplianceData, HomeConnectConfigEntry
-from .entity import HomeConnectEntity
+from .entity import HomeConnectEntity, HomeConnectOptionEntity
 from .utils import get_dict_from_home_connect_error
 
 _LOGGER = logging.getLogger(__name__)
 
+PARALLEL_UPDATES = 1
+
+UNIT_MAP = {
+    "seconds": UnitOfTime.SECONDS,
+    "ml": UnitOfVolume.MILLILITERS,
+    "°C": UnitOfTemperature.CELSIUS,
+    "°F": UnitOfTemperature.FAHRENHEIT,
+}
 
 NUMBERS = (
     NumberEntityDescription(
@@ -76,6 +85,11 @@ NUMBERS = (
         device_class=NumberDeviceClass.TEMPERATURE,
         translation_key="wine_compartment_3_setpoint_temperature",
     ),
+    NumberEntityDescription(
+        key=SettingKey.COOKING_HOOD_COLOR_TEMPERATURE_PERCENT,
+        translation_key="color_temperature_percent",
+        native_unit_of_measurement="%",
+    ),
     NumberEntityDescription(
         key=SettingKey.LAUNDRY_CARE_WASHER_I_DOS_1_BASE_LEVEL,
         device_class=NumberDeviceClass.VOLUME,
@@ -88,6 +102,32 @@ NUMBERS = (
     ),
 )
 
+NUMBER_OPTIONS = (
+    NumberEntityDescription(
+        key=OptionKey.BSH_COMMON_DURATION,
+        translation_key="duration",
+    ),
+    NumberEntityDescription(
+        key=OptionKey.BSH_COMMON_FINISH_IN_RELATIVE,
+        translation_key="finish_in_relative",
+    ),
+    NumberEntityDescription(
+        key=OptionKey.BSH_COMMON_START_IN_RELATIVE,
+        translation_key="start_in_relative",
+    ),
+    NumberEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_FILL_QUANTITY,
+        translation_key="fill_quantity",
+        device_class=NumberDeviceClass.VOLUME,
+        native_step=1,
+    ),
+    NumberEntityDescription(
+        key=OptionKey.COOKING_OVEN_SETPOINT_TEMPERATURE,
+        translation_key="setpoint_temperature",
+        device_class=NumberDeviceClass.TEMPERATURE,
+    ),
+)
+
 
 def _get_entities_for_appliance(
     entry: HomeConnectConfigEntry,
@@ -101,6 +141,18 @@ def _get_entities_for_appliance(
     ]
 
 
+def _get_option_entities_for_appliance(
+    entry: HomeConnectConfigEntry,
+    appliance: HomeConnectApplianceData,
+) -> list[HomeConnectOptionEntity]:
+    """Get a list of currently available option entities."""
+    return [
+        HomeConnectOptionNumberEntity(entry.runtime_data, appliance, description)
+        for description in NUMBER_OPTIONS
+        if description.key in appliance.options
+    ]
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: HomeConnectConfigEntry,
@@ -111,6 +163,7 @@ async def async_setup_entry(
         entry,
         _get_entities_for_appliance,
         async_add_entities,
+        _get_option_entities_for_appliance,
     )
 
 
@@ -184,3 +237,44 @@ class HomeConnectNumberEntity(HomeConnectEntity, NumberEntity):
             or not hasattr(self, "_attr_native_step")
         ):
             await self.async_fetch_constraints()
+
+
+class HomeConnectOptionNumberEntity(HomeConnectOptionEntity, NumberEntity):
+    """Number option class for Home Connect."""
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Set the native value of the entity."""
+        await self.async_set_option(value)
+
+    def update_native_value(self) -> None:
+        """Set the value of the entity."""
+        self._attr_native_value = cast(float | None, self.option_value)
+        option_definition = self.appliance.options.get(self.bsh_key)
+        if option_definition:
+            if option_definition.unit:
+                candidate_unit = UNIT_MAP.get(
+                    option_definition.unit, option_definition.unit
+                )
+                if (
+                    not hasattr(self, "_attr_native_unit_of_measurement")
+                    or candidate_unit != self._attr_native_unit_of_measurement
+                ):
+                    self._attr_native_unit_of_measurement = candidate_unit
+                    self.__dict__.pop("unit_of_measurement", None)
+            option_constraints = option_definition.constraints
+            if option_constraints:
+                if (
+                    not hasattr(self, "_attr_native_min_value")
+                    or self._attr_native_min_value != option_constraints.min
+                ) and option_constraints.min:
+                    self._attr_native_min_value = option_constraints.min
+                if (
+                    not hasattr(self, "_attr_native_max_value")
+                    or self._attr_native_max_value != option_constraints.max
+                ) and option_constraints.max:
+                    self._attr_native_max_value = option_constraints.max
+                if (
+                    not hasattr(self, "_attr_native_step")
+                    or self._attr_native_step != option_constraints.step_size
+                ) and option_constraints.step_size:
+                    self._attr_native_step = option_constraints.step_size

homeassistant/components/home_connect/select.py

@@ -1,11 +1,12 @@
 """Provides a select platform for Home Connect."""
 
 from collections.abc import Callable, Coroutine
+import contextlib
 from dataclasses import dataclass
 from typing import Any, cast
 
 from aiohomeconnect.client import Client as HomeConnectClient
-from aiohomeconnect.model import EventKey, ProgramKey
+from aiohomeconnect.model import EventKey, OptionKey, ProgramKey, SettingKey
 from aiohomeconnect.model.error import HomeConnectError
 from aiohomeconnect.model.program import Execution
 
@@ -17,18 +18,62 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .common import setup_home_connect_entry
 from .const import (
     APPLIANCES_WITH_PROGRAMS,
+    AVAILABLE_MAPS_ENUM,
+    BEAN_AMOUNT_OPTIONS,
+    BEAN_CONTAINER_OPTIONS,
+    CLEANING_MODE_OPTIONS,
+    COFFEE_MILK_RATIO_OPTIONS,
+    COFFEE_TEMPERATURE_OPTIONS,
     DOMAIN,
+    DRYING_TARGET_OPTIONS,
+    FLOW_RATE_OPTIONS,
+    HOT_WATER_TEMPERATURE_OPTIONS,
+    INTENSIVE_LEVEL_OPTIONS,
     PROGRAMS_TRANSLATION_KEYS_MAP,
+    SPIN_SPEED_OPTIONS,
+    SVE_TRANSLATION_KEY_SET_SETTING,
+    SVE_TRANSLATION_PLACEHOLDER_ENTITY_ID,
+    SVE_TRANSLATION_PLACEHOLDER_KEY,
     SVE_TRANSLATION_PLACEHOLDER_PROGRAM,
+    SVE_TRANSLATION_PLACEHOLDER_VALUE,
+    TEMPERATURE_OPTIONS,
     TRANSLATION_KEYS_PROGRAMS_MAP,
+    VARIO_PERFECT_OPTIONS,
+    VENTING_LEVEL_OPTIONS,
+    WARMING_LEVEL_OPTIONS,
 )
 from .coordinator import (
     HomeConnectApplianceData,
     HomeConnectConfigEntry,
     HomeConnectCoordinator,
 )
-from .entity import HomeConnectEntity
-from .utils import get_dict_from_home_connect_error
+from .entity import HomeConnectEntity, HomeConnectOptionEntity
+from .utils import bsh_key_to_translation_key, get_dict_from_home_connect_error
+
+PARALLEL_UPDATES = 1
+
+FUNCTIONAL_LIGHT_COLOR_TEMPERATURE_ENUM = {
+    bsh_key_to_translation_key(option): option
+    for option in (
+        "Cooking.Hood.EnumType.ColorTemperature.custom",
+        "Cooking.Hood.EnumType.ColorTemperature.warm",
+        "Cooking.Hood.EnumType.ColorTemperature.warmToNeutral",
+        "Cooking.Hood.EnumType.ColorTemperature.neutral",
+        "Cooking.Hood.EnumType.ColorTemperature.neutralToCold",
+        "Cooking.Hood.EnumType.ColorTemperature.cold",
+    )
+}
+
+AMBIENT_LIGHT_COLOR_TEMPERATURE_ENUM = {
+    **{
+        bsh_key_to_translation_key(option): option
+        for option in ("BSH.Common.EnumType.AmbientLightColor.CustomColor",)
+    },
+    **{
+        str(option): f"BSH.Common.EnumType.AmbientLightColor.Color{option}"
+        for option in range(1, 100)
+    },
+}
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -44,6 +89,14 @@ class HomeConnectProgramSelectEntityDescription(
     error_translation_key: str
 
 
+@dataclass(frozen=True, kw_only=True)
+class HomeConnectSelectEntityDescription(SelectEntityDescription):
+    """Entity Description class for settings and options that have enumeration values."""
+
+    translation_key_values: dict[str, str]
+    values_translation_key: dict[str, str]
+
+
 PROGRAM_SELECT_ENTITY_DESCRIPTIONS = (
     HomeConnectProgramSelectEntityDescription(
         key=EventKey.BSH_COMMON_ROOT_ACTIVE_PROGRAM,
@@ -65,20 +118,225 @@ PROGRAM_SELECT_ENTITY_DESCRIPTIONS = (
     ),
 )
 
+SELECT_ENTITY_DESCRIPTIONS = (
+    HomeConnectSelectEntityDescription(
+        key=SettingKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_CURRENT_MAP,
+        translation_key="current_map",
+        options=list(AVAILABLE_MAPS_ENUM),
+        translation_key_values=AVAILABLE_MAPS_ENUM,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in AVAILABLE_MAPS_ENUM.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=SettingKey.COOKING_HOOD_COLOR_TEMPERATURE,
+        translation_key="functional_light_color_temperature",
+        options=list(FUNCTIONAL_LIGHT_COLOR_TEMPERATURE_ENUM),
+        translation_key_values=FUNCTIONAL_LIGHT_COLOR_TEMPERATURE_ENUM,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in FUNCTIONAL_LIGHT_COLOR_TEMPERATURE_ENUM.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=SettingKey.BSH_COMMON_AMBIENT_LIGHT_COLOR,
+        translation_key="ambient_light_color",
+        options=list(AMBIENT_LIGHT_COLOR_TEMPERATURE_ENUM),
+        translation_key_values=AMBIENT_LIGHT_COLOR_TEMPERATURE_ENUM,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in AMBIENT_LIGHT_COLOR_TEMPERATURE_ENUM.items()
+        },
+    ),
+)
+
+PROGRAM_SELECT_OPTION_ENTITY_DESCRIPTIONS = (
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_REFERENCE_MAP_ID,
+        translation_key="reference_map_id",
+        options=list(AVAILABLE_MAPS_ENUM),
+        translation_key_values=AVAILABLE_MAPS_ENUM,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in AVAILABLE_MAPS_ENUM.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_CLEANING_MODE,
+        translation_key="cleaning_mode",
+        options=list(CLEANING_MODE_OPTIONS),
+        translation_key_values=CLEANING_MODE_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in CLEANING_MODE_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_BEAN_AMOUNT,
+        translation_key="bean_amount",
+        options=list(BEAN_AMOUNT_OPTIONS),
+        translation_key_values=BEAN_AMOUNT_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in BEAN_AMOUNT_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_COFFEE_TEMPERATURE,
+        translation_key="coffee_temperature",
+        options=list(COFFEE_TEMPERATURE_OPTIONS),
+        translation_key_values=COFFEE_TEMPERATURE_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in COFFEE_TEMPERATURE_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_BEAN_CONTAINER_SELECTION,
+        translation_key="bean_container",
+        options=list(BEAN_CONTAINER_OPTIONS),
+        translation_key_values=BEAN_CONTAINER_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in BEAN_CONTAINER_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_FLOW_RATE,
+        translation_key="flow_rate",
+        options=list(FLOW_RATE_OPTIONS),
+        translation_key_values=FLOW_RATE_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in FLOW_RATE_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_COFFEE_MILK_RATIO,
+        translation_key="coffee_milk_ratio",
+        options=list(COFFEE_MILK_RATIO_OPTIONS),
+        translation_key_values=COFFEE_MILK_RATIO_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in FLOW_RATE_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_HOT_WATER_TEMPERATURE,
+        translation_key="hot_water_temperature",
+        options=list(HOT_WATER_TEMPERATURE_OPTIONS),
+        translation_key_values=HOT_WATER_TEMPERATURE_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in HOT_WATER_TEMPERATURE_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.LAUNDRY_CARE_DRYER_DRYING_TARGET,
+        translation_key="drying_target",
+        options=list(DRYING_TARGET_OPTIONS),
+        translation_key_values=DRYING_TARGET_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in DRYING_TARGET_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.COOKING_COMMON_HOOD_VENTING_LEVEL,
+        translation_key="venting_level",
+        options=list(VENTING_LEVEL_OPTIONS),
+        translation_key_values=VENTING_LEVEL_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in VENTING_LEVEL_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.COOKING_COMMON_HOOD_INTENSIVE_LEVEL,
+        translation_key="intensive_level",
+        options=list(INTENSIVE_LEVEL_OPTIONS),
+        translation_key_values=INTENSIVE_LEVEL_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in INTENSIVE_LEVEL_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.COOKING_OVEN_WARMING_LEVEL,
+        translation_key="warming_level",
+        options=list(WARMING_LEVEL_OPTIONS),
+        translation_key_values=WARMING_LEVEL_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in WARMING_LEVEL_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.LAUNDRY_CARE_WASHER_TEMPERATURE,
+        translation_key="washer_temperature",
+        options=list(TEMPERATURE_OPTIONS),
+        translation_key_values=TEMPERATURE_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in TEMPERATURE_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.LAUNDRY_CARE_WASHER_SPIN_SPEED,
+        translation_key="spin_speed",
+        options=list(SPIN_SPEED_OPTIONS),
+        translation_key_values=SPIN_SPEED_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in SPIN_SPEED_OPTIONS.items()
+        },
+    ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.LAUNDRY_CARE_COMMON_VARIO_PERFECT,
+        translation_key="vario_perfect",
+        options=list(VARIO_PERFECT_OPTIONS),
+        translation_key_values=VARIO_PERFECT_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in VARIO_PERFECT_OPTIONS.items()
+        },
+    ),
+)
+
 
 def _get_entities_for_appliance(
     entry: HomeConnectConfigEntry,
     appliance: HomeConnectApplianceData,
 ) -> list[HomeConnectEntity]:
     """Get a list of entities."""
-    return (
-        [
-            HomeConnectProgramSelectEntity(entry.runtime_data, appliance, desc)
-            for desc in PROGRAM_SELECT_ENTITY_DESCRIPTIONS
-        ]
-        if appliance.info.type in APPLIANCES_WITH_PROGRAMS
-        else []
-    )
+    return [
+        *(
+            [
+                HomeConnectProgramSelectEntity(entry.runtime_data, appliance, desc)
+                for desc in PROGRAM_SELECT_ENTITY_DESCRIPTIONS
+            ]
+            if appliance.info.type in APPLIANCES_WITH_PROGRAMS
+            else []
+        ),
+        *[
+            HomeConnectSelectEntity(entry.runtime_data, appliance, desc)
+            for desc in SELECT_ENTITY_DESCRIPTIONS
+            if desc.key in appliance.settings
+        ],
+    ]
+
+
+def _get_option_entities_for_appliance(
+    entry: HomeConnectConfigEntry,
+    appliance: HomeConnectApplianceData,
+) -> list[HomeConnectOptionEntity]:
+    """Get a list of entities."""
+    return [
+        HomeConnectSelectOptionEntity(entry.runtime_data, appliance, desc)
+        for desc in PROGRAM_SELECT_OPTION_ENTITY_DESCRIPTIONS
+        if desc.key in appliance.options
+    ]
 
 
 async def async_setup_entry(
@@ -91,6 +349,7 @@ async def async_setup_entry(
         entry,
         _get_entities_for_appliance,
         async_add_entities,
+        _get_option_entities_for_appliance,
     )
 
 
@@ -148,3 +407,122 @@ class HomeConnectProgramSelectEntity(HomeConnectEntity, SelectEntity):
                     SVE_TRANSLATION_PLACEHOLDER_PROGRAM: program_key.value,
                 },
             ) from err
+
+
+class HomeConnectSelectEntity(HomeConnectEntity, SelectEntity):
+    """Select setting class for Home Connect."""
+
+    entity_description: HomeConnectSelectEntityDescription
+
+    def __init__(
+        self,
+        coordinator: HomeConnectCoordinator,
+        appliance: HomeConnectApplianceData,
+        desc: HomeConnectSelectEntityDescription,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(
+            coordinator,
+            appliance,
+            desc,
+        )
+
+    async def async_select_option(self, option: str) -> None:
+        """Select new option."""
+        value = self.entity_description.translation_key_values[option]
+        try:
+            await self.coordinator.client.set_setting(
+                self.appliance.info.ha_id,
+                setting_key=cast(SettingKey, self.bsh_key),
+                value=value,
+            )
+        except HomeConnectError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key=SVE_TRANSLATION_KEY_SET_SETTING,
+                translation_placeholders={
+                    **get_dict_from_home_connect_error(err),
+                    SVE_TRANSLATION_PLACEHOLDER_ENTITY_ID: self.entity_id,
+                    SVE_TRANSLATION_PLACEHOLDER_KEY: self.bsh_key,
+                    SVE_TRANSLATION_PLACEHOLDER_VALUE: value,
+                },
+            ) from err
+
+    def update_native_value(self) -> None:
+        """Set the value of the entity."""
+        data = self.appliance.settings[cast(SettingKey, self.bsh_key)]
+        self._attr_current_option = self.entity_description.values_translation_key.get(
+            data.value
+        )
+
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to hass."""
+        await super().async_added_to_hass()
+        setting = self.appliance.settings.get(cast(SettingKey, self.bsh_key))
+        if (
+            not setting
+            or not setting.constraints
+            or not setting.constraints.allowed_values
+        ):
+            with contextlib.suppress(HomeConnectError):
+                setting = await self.coordinator.client.get_setting(
+                    self.appliance.info.ha_id,
+                    setting_key=cast(SettingKey, self.bsh_key),
+                )
+
+        if setting and setting.constraints and setting.constraints.allowed_values:
+            self._attr_options = [
+                self.entity_description.values_translation_key[option]
+                for option in setting.constraints.allowed_values
+                if option in self.entity_description.values_translation_key
+            ]
+
+
+class HomeConnectSelectOptionEntity(HomeConnectOptionEntity, SelectEntity):
+    """Select option class for Home Connect."""
+
+    entity_description: HomeConnectSelectEntityDescription
+    _original_option_keys: set[str | None]
+
+    def __init__(
+        self,
+        coordinator: HomeConnectCoordinator,
+        appliance: HomeConnectApplianceData,
+        desc: HomeConnectSelectEntityDescription,
+    ) -> None:
+        """Initialize the entity."""
+        self._original_option_keys = set(desc.values_translation_key.keys())
+        super().__init__(
+            coordinator,
+            appliance,
+            desc,
+        )
+
+    async def async_select_option(self, option: str) -> None:
+        """Select new option."""
+        await self.async_set_option(
+            self.entity_description.translation_key_values[option]
+        )
+
+    def update_native_value(self) -> None:
+        """Set the value of the entity."""
+        self._attr_current_option = (
+            self.entity_description.values_translation_key.get(
+                cast(str, self.option_value), None
+            )
+            if self.option_value is not None
+            else None
+        )
+        if (
+            (option_definition := self.appliance.options.get(self.bsh_key))
+            and (option_constraints := option_definition.constraints)
+            and option_constraints.allowed_values
+            and self._original_option_keys != set(option_constraints.allowed_values)
+        ):
+            self._original_option_keys = set(option_constraints.allowed_values)
+            self._attr_options = [
+                self.entity_description.values_translation_key[option]
+                for option in self._original_option_keys
+                if option is not None
+            ]
+            self.__dict__.pop("options", None)

homeassistant/components/home_connect/sensor.py

@@ -12,7 +12,7 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfTime, UnitOfVolume
+from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfVolume
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util, slugify
@@ -27,6 +27,8 @@ from .const import (
 from .coordinator import HomeConnectApplianceData, HomeConnectConfigEntry
 from .entity import HomeConnectEntity
 
+PARALLEL_UPDATES = 0
+
 EVENT_OPTIONS = ["confirmed", "off", "present"]
 
 
@@ -56,12 +58,6 @@ BSH_PROGRAM_SENSORS = (
             "WasherDryer",
         ),
     ),
-    HomeConnectSensorEntityDescription(
-        key=EventKey.BSH_COMMON_OPTION_DURATION,
-        device_class=SensorDeviceClass.DURATION,
-        native_unit_of_measurement=UnitOfTime.SECONDS,
-        appliance_types=("Oven",),
-    ),
     HomeConnectSensorEntityDescription(
         key=EventKey.BSH_COMMON_OPTION_PROGRAM_PROGRESS,
         native_unit_of_measurement=PERCENTAGE,
@@ -183,6 +179,12 @@ SENSORS = (
         ],
         translation_key="last_selected_map",
     ),
+    HomeConnectSensorEntityDescription(
+        key=StatusKey.COOKING_OVEN_CURRENT_CAVITY_TEMPERATURE,
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="current_cavity_temperature",
+    ),
 )
 
 EVENT_SENSORS = (

homeassistant/components/home_connect/strings.json

@@ -33,6 +33,12 @@
     "appliance_not_found": {
       "message": "Appliance for device ID {device_id} not found"
     },
+    "device_entry_not_found": {
+      "message": "Device entry for device ID {device_id} not found"
+    },
+    "config_entry_not_found": {
+      "message": "Config entry for device ID {device_id} not found"
+    },
     "turn_on_light": {
       "message": "Error turning on {entity_id}: {error}"
     },
@@ -98,6 +104,9 @@
     },
     "required_program_or_one_option_at_least": {
       "message": "A program or at least one of the possible options for a program should be specified"
+    },
+    "set_option": {
+      "message": "Error setting the option for the program: {error}"
     }
   },
   "issues": {
@@ -105,6 +114,10 @@
       "title": "Deprecated binary door sensor detected in some automations or scripts",
       "description": "The binary door sensor `{entity}`, which is deprecated, is used in the following automations or scripts:\n{items}\n\nA sensor entity with additional possible states is available and should be used going forward; Please use it on the above automations or scripts to fix this issue."
     },
+    "deprecated_command_actions": {
+      "title": "The command related actions are deprecated in favor of the new buttons",
+      "description": "The `pause_program` and `resume_program` actions have been deprecated in favor of new button entities, if the command is available for your appliance. Please update your automations, scripts and panels that use this action to use the button entities instead, and press on submit to fix the issue."
+    },
     "deprecated_program_switch": {
       "title": "Deprecated program switch detected in some automations or scripts",
       "description": "Program switches are deprecated and {entity_id} is used in the following automations or scripts:\n{items}\n\nYou can use the active program select entity to run the program without any additional options and get the current running program on the above automations or scripts to fix this issue."
@@ -812,6 +825,23 @@
         "name": "Wine compartment door"
       }
     },
+    "button": {
+      "open_door": {
+        "name": "Open door"
+      },
+      "partly_open_door": {
+        "name": "Partly open door"
+      },
+      "pause_program": {
+        "name": "Pause program"
+      },
+      "resume_program": {
+        "name": "Resume program"
+      },
+      "stop_program": {
+        "name": "Stop program"
+      }
+    },
     "light": {
       "cooking_lighting": {
         "name": "Functional light"
@@ -854,11 +884,29 @@
       "wine_compartment_3_setpoint_temperature": {
         "name": "Wine compartment 3 temperature"
       },
+      "color_temperature_percent": {
+        "name": "Functional light color temperature percent"
+      },
       "washer_i_dos_1_base_level": {
         "name": "i-Dos 1 base level"
       },
       "washer_i_dos_2_base_level": {
         "name": "i-Dos 2 base level"
+      },
+      "duration": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::b_s_h_common_option_duration::name%]"
+      },
+      "start_in_relative": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::b_s_h_common_option_start_in_relative::name%]"
+      },
+      "finish_in_relative": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::b_s_h_common_option_finish_in_relative::name%]"
+      },
+      "fill_quantity": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_fill_quantity::name%]"
+      },
+      "setpoint_temperature": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::cooking_oven_option_setpoint_temperature::name%]"
       }
     },
     "select": {
@@ -1179,6 +1227,226 @@
           "laundry_care_washer_dryer_program_wash_and_dry_60": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_dryer_program_wash_and_dry_60%]",
           "laundry_care_washer_dryer_program_wash_and_dry_90": "[%key:component::home_connect::selector::programs::options::laundry_care_washer_dryer_program_wash_and_dry_90%]"
         }
+      },
+      "current_map": {
+        "name": "Current map",
+        "state": {
+          "consumer_products_cleaning_robot_enum_type_available_maps_temp_map": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_temp_map%]",
+          "consumer_products_cleaning_robot_enum_type_available_maps_map1": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_map1%]",
+          "consumer_products_cleaning_robot_enum_type_available_maps_map2": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_map2%]",
+          "consumer_products_cleaning_robot_enum_type_available_maps_map3": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_map3%]"
+        }
+      },
+      "functional_light_color_temperature": {
+        "name": "Functional light color temperature",
+        "state": {
+          "cooking_hood_enum_type_color_temperature_custom": "Custom",
+          "cooking_hood_enum_type_color_temperature_warm": "Warm",
+          "cooking_hood_enum_type_color_temperature_warm_to_neutral": "Warm to Neutral",
+          "cooking_hood_enum_type_color_temperature_neutral": "Neutral",
+          "cooking_hood_enum_type_color_temperature_neutral_to_cold": "Neutral to Cold",
+          "cooking_hood_enum_type_color_temperature_cold": "Cold"
+        }
+      },
+      "ambient_light_color": {
+        "name": "Ambient light color",
+        "state": {
+          "b_s_h_common_enum_type_ambient_light_color_custom_color": "Custom"
+        }
+      },
+      "reference_map_id": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_cleaning_robot_option_reference_map_id::name%]",
+        "state": {
+          "consumer_products_cleaning_robot_enum_type_available_maps_temp_map": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_temp_map%]",
+          "consumer_products_cleaning_robot_enum_type_available_maps_map1": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_map1%]",
+          "consumer_products_cleaning_robot_enum_type_available_maps_map2": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_map2%]",
+          "consumer_products_cleaning_robot_enum_type_available_maps_map3": "[%key:component::home_connect::selector::available_maps::options::consumer_products_cleaning_robot_enum_type_available_maps_map3%]"
+        }
+      },
+      "cleaning_mode": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_cleaning_robot_option_cleaning_mode::name%]",
+        "state": {
+          "consumer_products_cleaning_robot_enum_type_cleaning_modes_silent": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_silent%]",
+          "consumer_products_cleaning_robot_enum_type_cleaning_modes_standard": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_standard%]",
+          "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_power%]"
+        }
+      },
+      "bean_amount": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_bean_amount::name%]",
+        "state": {
+          "consumer_products_coffee_maker_enum_type_bean_amount_very_mild": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_very_mild%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_mild": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_mild%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_mild_plus": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_mild_plus%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_normal": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_normal%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_normal_plus": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_normal_plus%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_strong": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_strong%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_strong_plus": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_strong_plus%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_very_strong": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_very_strong%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_very_strong_plus": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_very_strong_plus%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_extra_strong": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_extra_strong%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_double_shot": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_double_shot%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_double_shot_plus": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_double_shot_plus%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_double_shot_plus_plus": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_double_shot_plus_plus%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_triple_shot": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_triple_shot%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_triple_shot_plus": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_triple_shot_plus%]",
+          "consumer_products_coffee_maker_enum_type_bean_amount_coffee_ground": "[%key:component::home_connect::selector::bean_amount::options::consumer_products_coffee_maker_enum_type_bean_amount_coffee_ground%]"
+        }
+      },
+      "coffee_temperature": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_coffee_temperature::name%]",
+        "state": {
+          "consumer_products_coffee_maker_enum_type_coffee_temperature_88_c": "[%key:component::home_connect::selector::coffee_temperature::options::consumer_products_coffee_maker_enum_type_coffee_temperature_88_c%]",
+          "consumer_products_coffee_maker_enum_type_coffee_temperature_90_c": "[%key:component::home_connect::selector::coffee_temperature::options::consumer_products_coffee_maker_enum_type_coffee_temperature_90_c%]",
+          "consumer_products_coffee_maker_enum_type_coffee_temperature_92_c": "[%key:component::home_connect::selector::coffee_temperature::options::consumer_products_coffee_maker_enum_type_coffee_temperature_92_c%]",
+          "consumer_products_coffee_maker_enum_type_coffee_temperature_94_c": "[%key:component::home_connect::selector::coffee_temperature::options::consumer_products_coffee_maker_enum_type_coffee_temperature_94_c%]",
+          "consumer_products_coffee_maker_enum_type_coffee_temperature_95_c": "[%key:component::home_connect::selector::coffee_temperature::options::consumer_products_coffee_maker_enum_type_coffee_temperature_95_c%]",
+          "consumer_products_coffee_maker_enum_type_coffee_temperature_96_c": "[%key:component::home_connect::selector::coffee_temperature::options::consumer_products_coffee_maker_enum_type_coffee_temperature_96_c%]"
+        }
+      },
+      "bean_container": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_bean_container::name%]",
+        "state": {
+          "consumer_products_coffee_maker_enum_type_bean_container_selection_right": "[%key:component::home_connect::selector::bean_container::options::consumer_products_coffee_maker_enum_type_bean_container_selection_right%]",
+          "consumer_products_coffee_maker_enum_type_bean_container_selection_left": "[%key:component::home_connect::selector::bean_container::options::consumer_products_coffee_maker_enum_type_bean_container_selection_left%]"
+        }
+      },
+      "flow_rate": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_flow_rate::name%]",
+        "state": {
+          "consumer_products_coffee_maker_enum_type_flow_rate_normal": "[%key:component::home_connect::selector::flow_rate::options::consumer_products_coffee_maker_enum_type_flow_rate_normal%]",
+          "consumer_products_coffee_maker_enum_type_flow_rate_intense": "[%key:component::home_connect::selector::flow_rate::options::consumer_products_coffee_maker_enum_type_flow_rate_intense%]",
+          "consumer_products_coffee_maker_enum_type_flow_rate_intense_plus": "[%key:component::home_connect::selector::flow_rate::options::consumer_products_coffee_maker_enum_type_flow_rate_intense_plus%]"
+        }
+      },
+      "coffee_milk_ratio": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_coffee_milk_ratio::name%]",
+        "state": {
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_10_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_10_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_20_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_20_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_25_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_25_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_30_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_30_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_40_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_40_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_50_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_50_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_55_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_55_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_60_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_60_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_65_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_65_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_67_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_67_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_70_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_70_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_75_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_75_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_80_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_80_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_85_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_85_percent%]",
+          "consumer_products_coffee_maker_enum_type_coffee_milk_ratio_90_percent": "[%key:component::home_connect::selector::coffee_milk_ratio::options::consumer_products_coffee_maker_enum_type_coffee_milk_ratio_90_percent%]"
+        }
+      },
+      "hot_water_temperature": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_hot_water_temperature::name%]",
+        "state": {
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_white_tea": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_white_tea%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_green_tea": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_green_tea%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_black_tea": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_black_tea%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_50_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_50_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_55_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_55_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_60_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_60_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_65_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_65_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_70_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_70_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_75_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_75_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_80_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_80_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_85_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_85_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_90_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_90_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_95_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_95_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_97_c": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_97_c%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_122_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_122_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_131_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_131_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_140_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_140_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_149_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_149_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_158_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_158_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_167_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_167_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_176_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_176_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_185_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_185_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_194_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_194_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_203_f": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_203_f%]",
+          "consumer_products_coffee_maker_enum_type_hot_water_temperature_max": "[%key:component::home_connect::selector::hot_water_temperature::options::consumer_products_coffee_maker_enum_type_hot_water_temperature_max%]"
+        }
+      },
+      "drying_target": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::laundry_care_dryer_option_drying_target::name%]",
+        "state": {
+          "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%]",
+          "laundry_care_dryer_enum_type_drying_target_gentle_dry": "[%key:component::home_connect::selector::drying_target::options::laundry_care_dryer_enum_type_drying_target_gentle_dry%]",
+          "laundry_care_dryer_enum_type_drying_target_cupboard_dry": "[%key:component::home_connect::selector::drying_target::options::laundry_care_dryer_enum_type_drying_target_cupboard_dry%]",
+          "laundry_care_dryer_enum_type_drying_target_cupboard_dry_plus": "[%key:component::home_connect::selector::drying_target::options::laundry_care_dryer_enum_type_drying_target_cupboard_dry_plus%]",
+          "laundry_care_dryer_enum_type_drying_target_extra_dry": "[%key:component::home_connect::selector::drying_target::options::laundry_care_dryer_enum_type_drying_target_extra_dry%]"
+        }
+      },
+      "venting_level": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::cooking_hood_option_venting_level::name%]",
+        "state": {
+          "cooking_hood_enum_type_stage_fan_off": "[%key:component::home_connect::selector::venting_level::options::cooking_hood_enum_type_stage_fan_off%]",
+          "cooking_hood_enum_type_stage_fan_stage01": "[%key:component::home_connect::selector::venting_level::options::cooking_hood_enum_type_stage_fan_stage01%]",
+          "cooking_hood_enum_type_stage_fan_stage02": "[%key:component::home_connect::selector::venting_level::options::cooking_hood_enum_type_stage_fan_stage02%]",
+          "cooking_hood_enum_type_stage_fan_stage03": "[%key:component::home_connect::selector::venting_level::options::cooking_hood_enum_type_stage_fan_stage03%]",
+          "cooking_hood_enum_type_stage_fan_stage04": "[%key:component::home_connect::selector::venting_level::options::cooking_hood_enum_type_stage_fan_stage04%]",
+          "cooking_hood_enum_type_stage_fan_stage05": "[%key:component::home_connect::selector::venting_level::options::cooking_hood_enum_type_stage_fan_stage05%]"
+        }
+      },
+      "intensive_level": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::cooking_hood_option_intensive_level::name%]",
+        "state": {
+          "cooking_hood_enum_type_intensive_stage_intensive_stage_off": "[%key:component::home_connect::selector::intensive_level::options::cooking_hood_enum_type_intensive_stage_intensive_stage_off%]",
+          "cooking_hood_enum_type_intensive_stage_intensive_stage1": "[%key:component::home_connect::selector::intensive_level::options::cooking_hood_enum_type_intensive_stage_intensive_stage1%]",
+          "cooking_hood_enum_type_intensive_stage_intensive_stage2": "[%key:component::home_connect::selector::intensive_level::options::cooking_hood_enum_type_intensive_stage_intensive_stage2%]"
+        }
+      },
+      "warming_level": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::cooking_oven_option_warming_level::name%]",
+        "state": {
+          "cooking_oven_enum_type_warming_level_low": "[%key:component::home_connect::selector::warming_level::options::cooking_oven_enum_type_warming_level_low%]",
+          "cooking_oven_enum_type_warming_level_medium": "[%key:component::home_connect::selector::warming_level::options::cooking_oven_enum_type_warming_level_medium%]",
+          "cooking_oven_enum_type_warming_level_high": "[%key:component::home_connect::selector::warming_level::options::cooking_oven_enum_type_warming_level_high%]"
+        }
+      },
+      "washer_temperature": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::laundry_care_washer_option_temperature::name%]",
+        "state": {
+          "laundry_care_washer_enum_type_temperature_cold": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_cold%]",
+          "laundry_care_washer_enum_type_temperature_g_c20": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c20%]",
+          "laundry_care_washer_enum_type_temperature_g_c30": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c30%]",
+          "laundry_care_washer_enum_type_temperature_g_c40": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c40%]",
+          "laundry_care_washer_enum_type_temperature_g_c50": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c50%]",
+          "laundry_care_washer_enum_type_temperature_g_c60": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c60%]",
+          "laundry_care_washer_enum_type_temperature_g_c70": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c70%]",
+          "laundry_care_washer_enum_type_temperature_g_c80": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c80%]",
+          "laundry_care_washer_enum_type_temperature_g_c90": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_g_c90%]",
+          "laundry_care_washer_enum_type_temperature_ul_cold": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_ul_cold%]",
+          "laundry_care_washer_enum_type_temperature_ul_warm": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_ul_warm%]",
+          "laundry_care_washer_enum_type_temperature_ul_hot": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_ul_hot%]",
+          "laundry_care_washer_enum_type_temperature_ul_extra_hot": "[%key:component::home_connect::selector::washer_temperature::options::laundry_care_washer_enum_type_temperature_ul_extra_hot%]"
+        }
+      },
+      "spin_speed": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::laundry_care_washer_option_spin_speed::name%]",
+        "state": {
+          "laundry_care_washer_enum_type_spin_speed_off": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_off%]",
+          "laundry_care_washer_enum_type_spin_speed_r_p_m400": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_r_p_m400%]",
+          "laundry_care_washer_enum_type_spin_speed_r_p_m600": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_r_p_m600%]",
+          "laundry_care_washer_enum_type_spin_speed_r_p_m800": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_r_p_m800%]",
+          "laundry_care_washer_enum_type_spin_speed_r_p_m1000": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_r_p_m1000%]",
+          "laundry_care_washer_enum_type_spin_speed_r_p_m1200": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_r_p_m1200%]",
+          "laundry_care_washer_enum_type_spin_speed_r_p_m1400": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_r_p_m1400%]",
+          "laundry_care_washer_enum_type_spin_speed_r_p_m1600": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_r_p_m1600%]",
+          "laundry_care_washer_enum_type_spin_speed_ul_off": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_ul_off%]",
+          "laundry_care_washer_enum_type_spin_speed_ul_low": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_ul_low%]",
+          "laundry_care_washer_enum_type_spin_speed_ul_medium": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_ul_medium%]",
+          "laundry_care_washer_enum_type_spin_speed_ul_high": "[%key:component::home_connect::selector::spin_speed::options::laundry_care_washer_enum_type_spin_speed_ul_high%]"
+        }
+      },
+      "vario_perfect": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::laundry_care_washer_option_vario_perfect::name%]",
+        "state": {
+          "laundry_care_common_enum_type_vario_perfect_off": "[%key:component::home_connect::selector::vario_perfect::options::laundry_care_common_enum_type_vario_perfect_off%]",
+          "laundry_care_common_enum_type_vario_perfect_eco_perfect": "[%key:component::home_connect::selector::vario_perfect::options::laundry_care_common_enum_type_vario_perfect_eco_perfect%]",
+          "laundry_care_common_enum_type_vario_perfect_speed_perfect": "[%key:component::home_connect::selector::vario_perfect::options::laundry_care_common_enum_type_vario_perfect_speed_perfect%]"
+        }
       }
     },
     "sensor": {
@@ -1261,6 +1529,9 @@
           "map3": "Map 3"
         }
       },
+      "current_cavity_temperature": {
+        "name": "Current cavity temperature"
+      },
       "freezer_door_alarm": {
         "name": "Freezer door alarm",
         "state": {
@@ -1365,6 +1636,45 @@
       },
       "door_assistant_freezer": {
         "name": "Freezer door assistant"
+      },
+      "multiple_beverages": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_coffee_maker_option_multiple_beverages::name%]"
+      },
+      "intensiv_zone": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_intensiv_zone::name%]"
+      },
+      "brilliance_dry": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_brilliance_dry::name%]"
+      },
+      "vario_speed_plus": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_vario_speed_plus::name%]"
+      },
+      "silence_on_demand": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_silence_on_demand::name%]"
+      },
+      "half_load": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_half_load::name%]"
+      },
+      "extra_dry": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_extra_dry::name%]"
+      },
+      "hygiene_plus": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_hygiene_plus::name%]"
+      },
+      "eco_dry": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_eco_dry::name%]"
+      },
+      "zeolite_dry": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::dishcare_dishwasher_option_zeolite_dry::name%]"
+      },
+      "fast_pre_heat": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::cooking_oven_option_fast_pre_heat::name%]"
+      },
+      "i_dos1_active": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::laundry_care_washer_option_i_dos1_active::name%]"
+      },
+      "i_dos2_active": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::laundry_care_washer_option_i_dos2_active::name%]"
       }
     },
     "time": {

homeassistant/components/home_connect/switch.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Any, cast
 
-from aiohomeconnect.model import EventKey, ProgramKey, SettingKey
+from aiohomeconnect.model import EventKey, OptionKey, ProgramKey, SettingKey
 from aiohomeconnect.model.error import HomeConnectError
 from aiohomeconnect.model.program import EnumerateProgram
 
@@ -37,11 +37,12 @@ from .coordinator import (
     HomeConnectConfigEntry,
     HomeConnectCoordinator,
 )
-from .entity import HomeConnectEntity
+from .entity import HomeConnectEntity, HomeConnectOptionEntity
 from .utils import get_dict_from_home_connect_error
 
 _LOGGER = logging.getLogger(__name__)
 
+PARALLEL_UPDATES = 1
 
 SWITCHES = (
     SwitchEntityDescription(
@@ -100,6 +101,61 @@ POWER_SWITCH_DESCRIPTION = SwitchEntityDescription(
     translation_key="power",
 )
 
+SWITCH_OPTIONS = (
+    SwitchEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_MULTIPLE_BEVERAGES,
+        translation_key="multiple_beverages",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_INTENSIV_ZONE,
+        translation_key="intensiv_zone",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_BRILLIANCE_DRY,
+        translation_key="brilliance_dry",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_VARIO_SPEED_PLUS,
+        translation_key="vario_speed_plus",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_SILENCE_ON_DEMAND,
+        translation_key="silence_on_demand",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_HALF_LOAD,
+        translation_key="half_load",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_EXTRA_DRY,
+        translation_key="extra_dry",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_HYGIENE_PLUS,
+        translation_key="hygiene_plus",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_ECO_DRY,
+        translation_key="eco_dry",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.DISHCARE_DISHWASHER_ZEOLITE_DRY,
+        translation_key="zeolite_dry",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.COOKING_OVEN_FAST_PRE_HEAT,
+        translation_key="fast_pre_heat",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.LAUNDRY_CARE_WASHER_I_DOS_1_ACTIVE,
+        translation_key="i_dos1_active",
+    ),
+    SwitchEntityDescription(
+        key=OptionKey.LAUNDRY_CARE_WASHER_I_DOS_2_ACTIVE,
+        translation_key="i_dos2_active",
+    ),
+)
+
 
 def _get_entities_for_appliance(
     entry: HomeConnectConfigEntry,
@@ -123,10 +179,21 @@ def _get_entities_for_appliance(
         for description in SWITCHES
         if description.key in appliance.settings
     )
-
     return entities
 
 
+def _get_option_entities_for_appliance(
+    entry: HomeConnectConfigEntry,
+    appliance: HomeConnectApplianceData,
+) -> list[HomeConnectOptionEntity]:
+    """Get a list of currently available option entities."""
+    return [
+        HomeConnectSwitchOptionEntity(entry.runtime_data, appliance, description)
+        for description in SWITCH_OPTIONS
+        if description.key in appliance.options
+    ]
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: HomeConnectConfigEntry,
@@ -137,6 +204,7 @@ async def async_setup_entry(
         entry,
         _get_entities_for_appliance,
         async_add_entities,
+        _get_option_entities_for_appliance,
     )
 
 
@@ -403,3 +471,19 @@ class HomeConnectPowerSwitch(HomeConnectEntity, SwitchEntity):
             self.power_off_state = BSH_POWER_STANDBY
         else:
             self.power_off_state = None
+
+
+class HomeConnectSwitchOptionEntity(HomeConnectOptionEntity, SwitchEntity):
+    """Switch option class for Home Connect."""
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn on the option."""
+        await self.async_set_option(True)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn off the option."""
+        await self.async_set_option(False)
+
+    def update_native_value(self) -> None:
+        """Set the value of the entity."""
+        self._attr_is_on = cast(bool | None, self.option_value)

homeassistant/components/home_connect/time.py

@@ -23,6 +23,8 @@ from .coordinator import HomeConnectApplianceData, HomeConnectConfigEntry
 from .entity import HomeConnectEntity
 from .utils import get_dict_from_home_connect_error
 
+PARALLEL_UPDATES = 1
+
 TIME_ENTITIES = (
     TimeEntityDescription(
         key=SettingKey.BSH_COMMON_ALARM_CLOCK,

homeassistant/components/homeassistant_hardware/firmware_config_flow.py

@@ -28,12 +28,13 @@ from . import silabs_multiprotocol_addon
 from .const import OTBR_DOMAIN, ZHA_DOMAIN
 from .util import (
     ApplicationType,
+    FirmwareInfo,
     OwningAddon,
     OwningIntegration,
     get_otbr_addon_manager,
     get_zigbee_flasher_addon_manager,
     guess_hardware_owners,
-    probe_silabs_firmware_type,
+    probe_silabs_firmware_info,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -52,7 +53,7 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         """Instantiate base flow."""
         super().__init__(*args, **kwargs)
 
-        self._probed_firmware_type: ApplicationType | None = None
+        self._probed_firmware_info: FirmwareInfo | None = None
         self._device: str | None = None  # To be set in a subclass
         self._hardware_name: str = "unknown"  # To be set in a subclass
 
@@ -64,8 +65,8 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         """Shared translation placeholders."""
         placeholders = {
             "firmware_type": (
-                self._probed_firmware_type.value
-                if self._probed_firmware_type is not None
+                self._probed_firmware_info.firmware_type.value
+                if self._probed_firmware_info is not None
                 else "unknown"
             ),
             "model": self._hardware_name,
@@ -120,39 +121,49 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
             description_placeholders=self._get_translation_placeholders(),
         )
 
-    async def _probe_firmware_type(self) -> bool:
-        """Probe the firmware currently on the device."""
-        assert self._device is not None
-
-        self._probed_firmware_type = await probe_silabs_firmware_type(
-            self._device,
-            probe_methods=(
-                # We probe in order of frequency: Zigbee, Thread, then multi-PAN
-                ApplicationType.GECKO_BOOTLOADER,
-                ApplicationType.EZSP,
-                ApplicationType.SPINEL,
-                ApplicationType.CPC,
-            ),
-        )
-
-        return self._probed_firmware_type in (
+    async def _probe_firmware_info(
+        self,
+        probe_methods: tuple[ApplicationType, ...] = (
+            # We probe in order of frequency: Zigbee, Thread, then multi-PAN
+            ApplicationType.GECKO_BOOTLOADER,
             ApplicationType.EZSP,
             ApplicationType.SPINEL,
             ApplicationType.CPC,
+        ),
+    ) -> bool:
+        """Probe the firmware currently on the device."""
+        assert self._device is not None
+
+        self._probed_firmware_info = await probe_silabs_firmware_info(
+            self._device,
+            probe_methods=probe_methods,
+        )
+
+        return (
+            self._probed_firmware_info is not None
+            and self._probed_firmware_info.firmware_type
+            in (
+                ApplicationType.EZSP,
+                ApplicationType.SPINEL,
+                ApplicationType.CPC,
+            )
         )
 
     async def async_step_pick_firmware_zigbee(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Pick Zigbee firmware."""
-        if not await self._probe_firmware_type():
+        if not await self._probe_firmware_info():
             return self.async_abort(
                 reason="unsupported_firmware",
                 description_placeholders=self._get_translation_placeholders(),
             )
 
         # Allow the stick to be used with ZHA without flashing
-        if self._probed_firmware_type == ApplicationType.EZSP:
+        if (
+            self._probed_firmware_info is not None
+            and self._probed_firmware_info.firmware_type == ApplicationType.EZSP
+        ):
             return await self.async_step_confirm_zigbee()
 
         if not is_hassio(self.hass):
@@ -338,7 +349,12 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         """Confirm Zigbee setup."""
         assert self._device is not None
         assert self._hardware_name is not None
-        self._probed_firmware_type = ApplicationType.EZSP
+
+        if not await self._probe_firmware_info(probe_methods=(ApplicationType.EZSP,)):
+            return self.async_abort(
+                reason="unsupported_firmware",
+                description_placeholders=self._get_translation_placeholders(),
+            )
 
         if user_input is not None:
             await self.hass.config_entries.flow.async_init(
@@ -366,7 +382,7 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Pick Thread firmware."""
-        if not await self._probe_firmware_type():
+        if not await self._probe_firmware_info():
             return self.async_abort(
                 reason="unsupported_firmware",
                 description_placeholders=self._get_translation_placeholders(),
@@ -458,7 +474,11 @@ class BaseFirmwareInstallFlow(ConfigEntryBaseFlow, ABC):
         """Confirm OTBR setup."""
         assert self._device is not None
 
-        self._probed_firmware_type = ApplicationType.SPINEL
+        if not await self._probe_firmware_info(probe_methods=(ApplicationType.SPINEL,)):
+            return self.async_abort(
+                reason="unsupported_firmware",
+                description_placeholders=self._get_translation_placeholders(),
+            )
 
         if user_input is not None:
             # OTBR discovery is done automatically via hassio
@@ -497,14 +517,14 @@ class BaseFirmwareConfigFlow(BaseFirmwareInstallFlow, ConfigFlow):
 class BaseFirmwareOptionsFlow(BaseFirmwareInstallFlow, OptionsFlow):
     """Zigbee and Thread options flow handlers."""
 
+    _probed_firmware_info: FirmwareInfo
+
     def __init__(self, config_entry: ConfigEntry, *args: Any, **kwargs: Any) -> None:
         """Instantiate options flow."""
         super().__init__(*args, **kwargs)
 
         self._config_entry = config_entry
 
-        self._probed_firmware_type = ApplicationType(self.config_entry.data["firmware"])
-
         # Make `context` a regular dictionary
         self.context = {}
 

homeassistant/components/homeassistant_hardware/manifest.json

@@ -5,5 +5,5 @@
   "codeowners": ["@home-assistant/core"],
   "documentation": "https://www.home-assistant.io/integrations/homeassistant_hardware",
   "integration_type": "system",
-  "requirements": ["universal-silabs-flasher==0.0.25"]
+  "requirements": ["universal-silabs-flasher==0.0.29"]
 }

homeassistant/components/homeassistant_hardware/util.py

@@ -42,6 +42,7 @@ class ApplicationType(StrEnum):
     CPC = "cpc"
     EZSP = "ezsp"
     SPINEL = "spinel"
+    ROUTER = "router"
 
     @classmethod
     def from_flasher_application_type(
@@ -248,10 +249,10 @@ async def guess_firmware_info(hass: HomeAssistant, device_path: str) -> Firmware
     return guesses[-1][0]
 
 
-async def probe_silabs_firmware_type(
+async def probe_silabs_firmware_info(
     device: str, *, probe_methods: Iterable[ApplicationType] | None = None
-) -> ApplicationType | None:
-    """Probe the running firmware on a Silabs device."""
+) -> FirmwareInfo | None:
+    """Probe the running firmware on a SiLabs device."""
     flasher = Flasher(
         device=device,
         **(
@@ -269,4 +270,26 @@ async def probe_silabs_firmware_type(
     if flasher.app_type is None:
         return None
 
-    return ApplicationType.from_flasher_application_type(flasher.app_type)
+    return FirmwareInfo(
+        device=device,
+        firmware_type=ApplicationType.from_flasher_application_type(flasher.app_type),
+        firmware_version=(
+            flasher.app_version.orig_version
+            if flasher.app_version is not None
+            else None
+        ),
+        source="probe",
+        owners=[],
+    )
+
+
+async def probe_silabs_firmware_type(
+    device: str, *, probe_methods: Iterable[ApplicationType] | None = None
+) -> ApplicationType | None:
+    """Probe the running firmware type on a SiLabs device."""
+
+    fw_info = await probe_silabs_firmware_info(device, probe_methods=probe_methods)
+    if fw_info is None:
+        return None
+
+    return fw_info.firmware_type

homeassistant/components/homeassistant_sky_connect/config_flow.py

@@ -10,7 +10,10 @@ from homeassistant.components.homeassistant_hardware import (
     firmware_config_flow,
     silabs_multiprotocol_addon,
 )
-from homeassistant.components.homeassistant_hardware.util import ApplicationType
+from homeassistant.components.homeassistant_hardware.util import (
+    ApplicationType,
+    FirmwareInfo,
+)
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigEntryBaseFlow,
@@ -118,7 +121,7 @@ class HomeAssistantSkyConnectConfigFlow(
         """Create the config entry."""
         assert self._usb_info is not None
         assert self._hw_variant is not None
-        assert self._probed_firmware_type is not None
+        assert self._probed_firmware_info is not None
 
         return self.async_create_entry(
             title=self._hw_variant.full_name,
@@ -130,7 +133,7 @@ class HomeAssistantSkyConnectConfigFlow(
                 "description": self._usb_info.description,  # For backwards compatibility
                 "product": self._usb_info.description,
                 "device": self._usb_info.device,
-                "firmware": self._probed_firmware_type.value,
+                "firmware": self._probed_firmware_info.firmware_type.value,
             },
         )
 
@@ -203,18 +206,26 @@ class HomeAssistantSkyConnectOptionsFlowHandler(
         self._hardware_name = self._hw_variant.full_name
         self._device = self._usb_info.device
 
+        self._probed_firmware_info = FirmwareInfo(
+            device=self._device,
+            firmware_type=ApplicationType(self.config_entry.data["firmware"]),
+            firmware_version=None,
+            source="guess",
+            owners=[],
+        )
+
         # Regenerate the translation placeholders
         self._get_translation_placeholders()
 
     def _async_flow_finished(self) -> ConfigFlowResult:
         """Create the config entry."""
-        assert self._probed_firmware_type is not None
+        assert self._probed_firmware_info is not None
 
         self.hass.config_entries.async_update_entry(
             entry=self.config_entry,
             data={
                 **self.config_entry.data,
-                "firmware": self._probed_firmware_type.value,
+                "firmware": self._probed_firmware_info.firmware_type.value,
             },
             options=self.config_entry.options,
         )

homeassistant/components/homeassistant_yellow/config_flow.py

@@ -24,7 +24,10 @@ from homeassistant.components.homeassistant_hardware.silabs_multiprotocol_addon
     OptionsFlowHandler as MultiprotocolOptionsFlowHandler,
     SerialPortSettings as MultiprotocolSerialPortSettings,
 )
-from homeassistant.components.homeassistant_hardware.util import ApplicationType
+from homeassistant.components.homeassistant_hardware.util import (
+    ApplicationType,
+    FirmwareInfo,
+)
 from homeassistant.config_entries import (
     SOURCE_HARDWARE,
     ConfigEntry,
@@ -79,10 +82,13 @@ class HomeAssistantYellowConfigFlow(BaseFirmwareConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle the initial step."""
         # We do not actually use any portion of `BaseFirmwareConfigFlow` beyond this
-        await self._probe_firmware_type()
+        await self._probe_firmware_info()
 
         # Kick off ZHA hardware discovery automatically if Zigbee firmware is running
-        if self._probed_firmware_type is ApplicationType.EZSP:
+        if (
+            self._probed_firmware_info is not None
+            and self._probed_firmware_info.firmware_type is ApplicationType.EZSP
+        ):
             discovery_flow.async_create_flow(
                 self.hass,
                 ZHA_DOMAIN,
@@ -98,7 +104,11 @@ class HomeAssistantYellowConfigFlow(BaseFirmwareConfigFlow, domain=DOMAIN):
             title=BOARD_NAME,
             data={
                 # Assume the firmware type is EZSP if we cannot probe it
-                FIRMWARE: (self._probed_firmware_type or ApplicationType.EZSP).value,
+                FIRMWARE: (
+                    self._probed_firmware_info.firmware_type
+                    if self._probed_firmware_info is not None
+                    else ApplicationType.EZSP
+                ).value,
             },
         )
 
@@ -264,6 +274,14 @@ class HomeAssistantYellowOptionsFlowHandler(
         self._hardware_name = BOARD_NAME
         self._device = RADIO_DEVICE
 
+        self._probed_firmware_info = FirmwareInfo(
+            device=self._device,
+            firmware_type=ApplicationType(self.config_entry.data["firmware"]),
+            firmware_version=None,
+            source="guess",
+            owners=[],
+        )
+
         # Regenerate the translation placeholders
         self._get_translation_placeholders()
 
@@ -285,13 +303,13 @@ class HomeAssistantYellowOptionsFlowHandler(
 
     def _async_flow_finished(self) -> ConfigFlowResult:
         """Create the config entry."""
-        assert self._probed_firmware_type is not None
+        assert self._probed_firmware_info is not None
 
         self.hass.config_entries.async_update_entry(
             entry=self.config_entry,
             data={
                 **self.config_entry.data,
-                FIRMWARE: self._probed_firmware_type.value,
+                FIRMWARE: self._probed_firmware_info.firmware_type.value,
             },
         )
 

homeassistant/components/homee/__init__.py

@@ -18,8 +18,10 @@ PLATFORMS = [
     Platform.BUTTON,
     Platform.COVER,
     Platform.LIGHT,
+    Platform.NUMBER,
     Platform.SENSOR,
     Platform.SWITCH,
+    Platform.VALVE,
 ]
 
 type HomeeConfigEntry = ConfigEntry[Homee]

homeassistant/components/homee/button.py

@@ -75,4 +75,4 @@ class HomeeButton(HomeeEntity, ButtonEntity):
 
     async def async_press(self) -> None:
         """Handle the button press."""
-        await self.async_set_value(1)
+        await self.async_set_homee_value(1)

homeassistant/components/homee/cover.py

@@ -205,17 +205,17 @@ class HomeeCover(HomeeNodeEntity, CoverEntity):
         """Open the cover."""
         assert self._open_close_attribute is not None
         if not self._open_close_attribute.is_reversed:
-            await self.async_set_value(self._open_close_attribute, 0)
+            await self.async_set_homee_value(self._open_close_attribute, 0)
         else:
-            await self.async_set_value(self._open_close_attribute, 1)
+            await self.async_set_homee_value(self._open_close_attribute, 1)
 
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close cover."""
         assert self._open_close_attribute is not None
         if not self._open_close_attribute.is_reversed:
-            await self.async_set_value(self._open_close_attribute, 1)
+            await self.async_set_homee_value(self._open_close_attribute, 1)
         else:
-            await self.async_set_value(self._open_close_attribute, 0)
+            await self.async_set_homee_value(self._open_close_attribute, 0)
 
     async def async_set_cover_position(self, **kwargs: Any) -> None:
         """Move the cover to a specific position."""
@@ -230,12 +230,12 @@ class HomeeCover(HomeeNodeEntity, CoverEntity):
                 homee_max = attribute.maximum
                 homee_position = (position / 100) * (homee_max - homee_min) + homee_min
 
-                await self.async_set_value(attribute, homee_position)
+                await self.async_set_homee_value(attribute, homee_position)
 
     async def async_stop_cover(self, **kwargs: Any) -> None:
         """Stop the cover."""
         if self._open_close_attribute is not None:
-            await self.async_set_value(self._open_close_attribute, 2)
+            await self.async_set_homee_value(self._open_close_attribute, 2)
 
     async def async_open_cover_tilt(self, **kwargs: Any) -> None:
         """Open the cover tilt."""
@@ -245,9 +245,9 @@ class HomeeCover(HomeeNodeEntity, CoverEntity):
             )
         ) is not None:
             if not slat_attribute.is_reversed:
-                await self.async_set_value(slat_attribute, 2)
+                await self.async_set_homee_value(slat_attribute, 2)
             else:
-                await self.async_set_value(slat_attribute, 1)
+                await self.async_set_homee_value(slat_attribute, 1)
 
     async def async_close_cover_tilt(self, **kwargs: Any) -> None:
         """Close the cover tilt."""
@@ -257,9 +257,9 @@ class HomeeCover(HomeeNodeEntity, CoverEntity):
             )
         ) is not None:
             if not slat_attribute.is_reversed:
-                await self.async_set_value(slat_attribute, 1)
+                await self.async_set_homee_value(slat_attribute, 1)
             else:
-                await self.async_set_value(slat_attribute, 2)
+                await self.async_set_homee_value(slat_attribute, 2)
 
     async def async_set_cover_tilt_position(self, **kwargs: Any) -> None:
         """Move the cover tilt to a specific position."""
@@ -276,4 +276,4 @@ class HomeeCover(HomeeNodeEntity, CoverEntity):
                 homee_max = attribute.maximum
                 homee_position = (position / 100) * (homee_max - homee_min) + homee_min
 
-                await self.async_set_value(attribute, homee_position)
+                await self.async_set_homee_value(attribute, homee_position)

homeassistant/components/homee/entity.py

@@ -54,7 +54,7 @@ class HomeeEntity(Entity):
         """Return the availability of the underlying node."""
         return (self._attribute.state == AttributeState.NORMAL) and self._host_connected
 
-    async def async_set_value(self, value: float) -> None:
+    async def async_set_homee_value(self, value: float) -> None:
         """Set an attribute value on the homee node."""
         homee = self._entry.runtime_data
         try:
@@ -144,7 +144,9 @@ class HomeeNodeEntity(Entity):
 
         return None
 
-    async def async_set_value(self, attribute: HomeeAttribute, value: float) -> None:
+    async def async_set_homee_value(
+        self, attribute: HomeeAttribute, value: float
+    ) -> None:
         """Set an attribute value on the homee node."""
         homee = self._entry.runtime_data
         try:

homeassistant/components/homee/light.py

@@ -175,24 +175,26 @@ class HomeeLight(HomeeNodeEntity, LightEntity):
                     kwargs[ATTR_BRIGHTNESS],
                 )
             )
-            await self.async_set_value(self._dimmer_attr, target_value)
+            await self.async_set_homee_value(self._dimmer_attr, target_value)
         else:
             # If no brightness value is given, just turn on.
-            await self.async_set_value(self._on_off_attr, 1)
+            await self.async_set_homee_value(self._on_off_attr, 1)
 
         if ATTR_COLOR_TEMP_KELVIN in kwargs and self._temp_attr is not None:
-            await self.async_set_value(self._temp_attr, kwargs[ATTR_COLOR_TEMP_KELVIN])
+            await self.async_set_homee_value(
+                self._temp_attr, kwargs[ATTR_COLOR_TEMP_KELVIN]
+            )
         if ATTR_HS_COLOR in kwargs:
             color = kwargs[ATTR_HS_COLOR]
             if self._col_attr is not None:
-                await self.async_set_value(
+                await self.async_set_homee_value(
                     self._col_attr,
                     rgb_list_to_decimal(color_hs_to_RGB(*color)),
                 )
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""
-        await self.async_set_value(self._on_off_attr, 0)
+        await self.async_set_homee_value(self._on_off_attr, 0)
 
     def _get_supported_color_modes(self) -> set[ColorMode]:
         """Determine the supported color modes from the available attributes."""

homeassistant/components/homee/number.py

@@ -0,0 +1,130 @@
+"""The Homee number platform."""
+
+from pyHomee.const import AttributeType
+from pyHomee.model import HomeeAttribute
+
+from homeassistant.components.number import (
+    NumberDeviceClass,
+    NumberEntity,
+    NumberEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import HomeeConfigEntry
+from .const import HOMEE_UNIT_TO_HA_UNIT
+from .entity import HomeeEntity
+
+NUMBER_DESCRIPTIONS = {
+    AttributeType.DOWN_POSITION: NumberEntityDescription(
+        key="down_position",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.DOWN_SLAT_POSITION: NumberEntityDescription(
+        key="down_slat_position",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.DOWN_TIME: NumberEntityDescription(
+        key="down_time",
+        device_class=NumberDeviceClass.DURATION,
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.ENDPOSITION_CONFIGURATION: NumberEntityDescription(
+        key="endposition_configuration",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.MOTION_ALARM_CANCELATION_DELAY: NumberEntityDescription(
+        key="motion_alarm_cancelation_delay",
+        device_class=NumberDeviceClass.DURATION,
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.OPEN_WINDOW_DETECTION_SENSIBILITY: NumberEntityDescription(
+        key="open_window_detection_sensibility",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.POLLING_INTERVAL: NumberEntityDescription(
+        key="polling_interval",
+        device_class=NumberDeviceClass.DURATION,
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.SHUTTER_SLAT_TIME: NumberEntityDescription(
+        key="shutter_slat_time",
+        device_class=NumberDeviceClass.DURATION,
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.SLAT_MAX_ANGLE: NumberEntityDescription(
+        key="slat_max_angle",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.SLAT_MIN_ANGLE: NumberEntityDescription(
+        key="slat_min_angle",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.SLAT_STEPS: NumberEntityDescription(
+        key="slat_steps",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.TEMPERATURE_OFFSET: NumberEntityDescription(
+        key="temperature_offset",
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.UP_TIME: NumberEntityDescription(
+        key="up_time",
+        device_class=NumberDeviceClass.DURATION,
+        entity_category=EntityCategory.CONFIG,
+    ),
+    AttributeType.WAKE_UP_INTERVAL: NumberEntityDescription(
+        key="wake_up_interval",
+        device_class=NumberDeviceClass.DURATION,
+        entity_category=EntityCategory.CONFIG,
+    ),
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: HomeeConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add the Homee platform for the number component."""
+
+    async_add_entities(
+        HomeeNumber(attribute, config_entry, NUMBER_DESCRIPTIONS[attribute.type])
+        for node in config_entry.runtime_data.nodes
+        for attribute in node.attributes
+        if attribute.type in NUMBER_DESCRIPTIONS and attribute.data != "fixed_value"
+    )
+
+
+class HomeeNumber(HomeeEntity, NumberEntity):
+    """Representation of a Homee number."""
+
+    def __init__(
+        self,
+        attribute: HomeeAttribute,
+        entry: HomeeConfigEntry,
+        description: NumberEntityDescription,
+    ) -> None:
+        """Initialize a Homee number entity."""
+        super().__init__(attribute, entry)
+        self.entity_description = description
+        self._attr_translation_key = description.key
+        self._attr_native_unit_of_measurement = HOMEE_UNIT_TO_HA_UNIT[attribute.unit]
+        self._attr_native_min_value = attribute.minimum
+        self._attr_native_max_value = attribute.maximum
+        self._attr_native_step = attribute.step_value
+
+    @property
+    def available(self) -> bool:
+        """Return the availability of the entity."""
+        return super().available and self._attribute.editable
+
+    @property
+    def native_value(self) -> int:
+        """Return the native value of the number."""
+        return int(self._attribute.current_value)
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Set the selected value."""
+        await self.async_set_homee_value(value)

homeassistant/components/homee/sensor.py

@@ -157,7 +157,7 @@ SENSOR_DESCRIPTIONS: dict[AttributeType, HomeeSensorEntityDescription] = {
     AttributeType.RAIN_FALL_TODAY: HomeeSensorEntityDescription(
         key="rainfall_day",
         device_class=SensorDeviceClass.PRECIPITATION,
-        state_class=SensorStateClass.MEASUREMENT,
+        state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     AttributeType.RELATIVE_HUMIDITY: HomeeSensorEntityDescription(
         key="humidity",

homeassistant/components/homee/strings.json

@@ -66,6 +66,50 @@
         "name": "Light {instance}"
       }
     },
+    "number": {
+      "down_position": {
+        "name": "Down position"
+      },
+      "down_slat_position": {
+        "name": "Down slat position"
+      },
+      "down_time": {
+        "name": "Down-movement duration"
+      },
+      "endposition_configuration": {
+        "name": "End position"
+      },
+      "motion_alarm_cancelation_delay": {
+        "name": "Motion alarm delay"
+      },
+      "open_window_detection_sensibility": {
+        "name": "Window open sensibility"
+      },
+      "polling_interval": {
+        "name": "Polling interval"
+      },
+      "shutter_slat_time": {
+        "name": "Slat turn duration"
+      },
+      "slat_max_angle": {
+        "name": "Maximum slat angle"
+      },
+      "slat_min_angle": {
+        "name": "Minimum slat angle"
+      },
+      "slat_steps": {
+        "name": "Slat steps"
+      },
+      "temperature_offset": {
+        "name": "Temperature offset"
+      },
+      "up_time": {
+        "name": "Up-movement duration"
+      },
+      "wake_up_interval": {
+        "name": "Wake-up interval"
+      }
+    },
     "sensor": {
       "brightness_instance": {
         "name": "Illuminance {instance}"
@@ -205,6 +249,11 @@
       "watchdog": {
         "name": "Watchdog"
       }
+    },
+    "valve": {
+      "valve_position": {
+        "name": "Valve position"
+      }
     }
   },
   "exceptions": {

homeassistant/components/homee/switch.py

@@ -120,8 +120,8 @@ class HomeeSwitch(HomeeEntity, SwitchEntity):
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the switch on."""
-        await self.async_set_value(1)
+        await self.async_set_homee_value(1)
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the switch off."""
-        await self.async_set_value(0)
+        await self.async_set_homee_value(0)

homeassistant/components/homee/valve.py

@@ -0,0 +1,81 @@
+"""The Homee valve platform."""
+
+from pyHomee.const import AttributeType
+from pyHomee.model import HomeeAttribute
+
+from homeassistant.components.valve import (
+    ValveDeviceClass,
+    ValveEntity,
+    ValveEntityDescription,
+    ValveEntityFeature,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import HomeeConfigEntry
+from .entity import HomeeEntity
+
+VALVE_DESCRIPTIONS = {
+    AttributeType.CURRENT_VALVE_POSITION: ValveEntityDescription(
+        key="valve_position",
+        device_class=ValveDeviceClass.WATER,
+    )
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: HomeeConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add the Homee platform for the valve component."""
+
+    async_add_entities(
+        HomeeValve(attribute, config_entry, VALVE_DESCRIPTIONS[attribute.type])
+        for node in config_entry.runtime_data.nodes
+        for attribute in node.attributes
+        if attribute.type in VALVE_DESCRIPTIONS
+    )
+
+
+class HomeeValve(HomeeEntity, ValveEntity):
+    """Representation of a Homee valve."""
+
+    _attr_reports_position = True
+
+    def __init__(
+        self,
+        attribute: HomeeAttribute,
+        entry: HomeeConfigEntry,
+        description: ValveEntityDescription,
+    ) -> None:
+        """Initialize a Homee valve entity."""
+        super().__init__(attribute, entry)
+        self.entity_description = description
+        self._attr_translation_key = description.key
+
+    @property
+    def supported_features(self) -> ValveEntityFeature:
+        """Return the supported features."""
+        if self._attribute.editable:
+            return ValveEntityFeature.SET_POSITION
+        return ValveEntityFeature(0)
+
+    @property
+    def current_valve_position(self) -> int | None:
+        """Return the current valve position."""
+        return int(self._attribute.current_value)
+
+    @property
+    def is_closing(self) -> bool:
+        """Return if the valve is closing."""
+        return self._attribute.target_value < self._attribute.current_value
+
+    @property
+    def is_opening(self) -> bool:
+        """Return if the valve is opening."""
+        return self._attribute.target_value > self._attribute.current_value
+
+    async def async_set_valve_position(self, position: int) -> None:
+        """Move the valve to a specific position."""
+        await self.async_set_homee_value(position)