Merge branch 'dev' into add_event_entity_triggers

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

.claude/skills/integrations/SKILL.md

@@ -620,12 +620,14 @@ rules:
 
 ### Config Flow Testing
 - **100% Coverage Required**: All config flow paths must be tested
+- **Patch Boundaries**: Only patch library or client methods when testing config flows. Do not patch methods defined in `config_flow.py`; exercise the flow logic end-to-end.
 - **Test Scenarios**:
   - All flow initiation methods (user, discovery, import)
   - Successful configuration paths
   - Error recovery scenarios
   - Prevention of duplicate entries
   - Flow completion after errors
+  - Reauthentication/reconfigure flows
 
 ### Testing
 - **Integration-specific tests** (recommended):

.gitattributes

@@ -16,6 +16,7 @@ Dockerfile.dev linguist-language=Dockerfile
 CODEOWNERS linguist-generated=true
 Dockerfile linguist-generated=true
 homeassistant/generated/*.py linguist-generated=true
+machine/* linguist-generated=true
 mypy.ini linguist-generated=true
 requirements.txt linguist-generated=true
 requirements_all.txt linguist-generated=true

.github/workflows/builder.yml

@@ -35,6 +35,7 @@ jobs:
       channel: ${{ steps.version.outputs.channel }}
       publish: ${{ steps.version.outputs.publish }}
       architectures: ${{ env.ARCHITECTURES }}
+      base_image_version: ${{ env.BASE_IMAGE_VERSION }}
     steps:
       - name: Checkout the repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -100,7 +101,7 @@ jobs:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
         include:
           - arch: amd64
-            os: ubuntu-latest
+            os: ubuntu-24.04
           - arch: aarch64
             os: ubuntu-24.04-arm
     steps:
@@ -195,77 +196,20 @@ jobs:
         run: |
           echo "${GITHUB_SHA};${GITHUB_REF};${GITHUB_EVENT_NAME};${GITHUB_ACTOR}" > rootfs/OFFICIAL_IMAGE
 
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install Cosign
-        uses: sigstore/cosign-installer@ba7bc0a3fef59531c69a25acd34668d6d3fe6f22 # v4.1.0
-        with:
-          cosign-release: "v2.5.3"
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v4.0.0
-
-      - name: Build variables
-        id: vars
-        shell: bash
-        env:
-          ARCH: ${{ matrix.arch }}
-        run: |
-          echo "base_image=ghcr.io/home-assistant/${ARCH}-homeassistant-base:${BASE_IMAGE_VERSION}" >> "$GITHUB_OUTPUT"
-          echo "cache_image=ghcr.io/home-assistant/${ARCH}-homeassistant:latest" >> "$GITHUB_OUTPUT"
-          echo "created=$(date --rfc-3339=seconds --utc)" >> "$GITHUB_OUTPUT"
-
-      - name: Verify base image signature
-        env:
-          BASE_IMAGE: ${{ steps.vars.outputs.base_image }}
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/docker/.*" \
-            "${BASE_IMAGE}"
-
-      - name: Verify cache image signature
-        id: cache
-        continue-on-error: true
-        env:
-          CACHE_IMAGE: ${{ steps.vars.outputs.cache_image }}
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
-            "${CACHE_IMAGE}"
-
       - name: Build base image
-        id: build
-        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
+        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
         with:
-          context: .
-          file: ./Dockerfile
-          platforms: ${{ steps.vars.outputs.platform }}
-          push: true
-          cache-from: ${{ steps.cache.outcome == 'success' && steps.vars.outputs.cache_image || '' }}
+          arch: ${{ matrix.arch }}
           build-args: |
-            BUILD_FROM=${{ steps.vars.outputs.base_image }}
-          tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          outputs: type=image,push=true,compression=zstd,compression-level=9,force-compression=true,oci-mediatypes=true
-          labels: |
-            io.hass.arch=${{ matrix.arch }}
-            io.hass.version=${{ needs.init.outputs.version }}
-            org.opencontainers.image.created=${{ steps.vars.outputs.created }}
-            org.opencontainers.image.version=${{ needs.init.outputs.version }}
-
-      - name: Sign image
-        env:
-          ARCH: ${{ matrix.arch }}
-          VERSION: ${{ needs.init.outputs.version }}
-          DIGEST: ${{ steps.build.outputs.digest }}
-        run: |
-          cosign sign --yes "ghcr.io/home-assistant/${ARCH}-homeassistant:${VERSION}@${DIGEST}"
+            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
+          cache-gha: false
+          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
+          cosign-base-identity: "https://github.com/home-assistant/docker/.*"
+          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
+          image: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant
+          image-tags: ${{ needs.init.outputs.version }}
+          push: true
+          version: ${{ needs.init.outputs.version }}
 
   build_machine:
     name: Build ${{ matrix.machine }} machine core image
@@ -314,35 +258,38 @@ jobs:
         with:
           persist-credentials: false
 
-      - name: Set build additional args
+      - name: Compute extra tags
+        id: tags
+        shell: bash
         env:
           VERSION: ${{ needs.init.outputs.version }}
         run: |
-          # Create general tags
           if [[ "${VERSION}" =~ d ]]; then
-            echo "BUILD_ARGS=--additional-tag dev" >> $GITHUB_ENV
+            echo "extra_tags=dev" >> "$GITHUB_OUTPUT"
           elif [[ "${VERSION}" =~ b ]]; then
-            echo "BUILD_ARGS=--additional-tag beta" >> $GITHUB_ENV
+            echo "extra_tags=beta" >> "$GITHUB_OUTPUT"
           else
-            echo "BUILD_ARGS=--additional-tag stable" >> $GITHUB_ENV
+            echo "extra_tags=stable" >> "$GITHUB_OUTPUT"
           fi
 
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+      - name: Build machine image
+        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
         with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Build base image
-        uses: home-assistant/builder@6cb4fd3d1338b6e22d0958a4bcb53e0965ea63b4 # 2026.02.1
-        with:
-          image: ${{ matrix.arch }}
-          args: |
-            $BUILD_ARGS \
-            --target /data/machine \
-            --cosign \
-            --machine "${{ needs.init.outputs.version }}=${{ matrix.machine }}"
+          arch: ${{ matrix.arch }}
+          build-args: |
+            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          cache-gha: false
+          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
+          context: machine/
+          cosign-base-identity: "https://github.com/home-assistant/core/.*"
+          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          file: machine/${{ matrix.machine }}
+          image: ghcr.io/home-assistant/${{ matrix.machine }}-homeassistant
+          image-tags: |
+            ${{ needs.init.outputs.version }}
+            ${{ steps.tags.outputs.extra_tags }}
+          push: true
+          version: ${{ needs.init.outputs.version }}
 
   publish_ha:
     name: Publish version files

.strict-typing

@@ -173,6 +173,7 @@ homeassistant.components.dnsip.*
 homeassistant.components.doorbird.*
 homeassistant.components.dormakaba_dkey.*
 homeassistant.components.downloader.*
+homeassistant.components.dropbox.*
 homeassistant.components.droplet.*
 homeassistant.components.dsmr.*
 homeassistant.components.duckdns.*

CODEOWNERS

@@ -397,6 +397,8 @@ build.json @home-assistant/supervisor
 /tests/components/dremel_3d_printer/ @tkdrob
 /homeassistant/components/drop_connect/ @ChandlerSystems @pfrazer
 /tests/components/drop_connect/ @ChandlerSystems @pfrazer
+/homeassistant/components/dropbox/ @bdr99
+/tests/components/dropbox/ @bdr99
 /homeassistant/components/droplet/ @sarahseidman
 /tests/components/droplet/ @sarahseidman
 /homeassistant/components/dsmr/ @Robbie1221
@@ -1616,8 +1618,6 @@ build.json @home-assistant/supervisor
 /tests/components/srp_energy/ @briglx
 /homeassistant/components/starline/ @anonym-tsk
 /tests/components/starline/ @anonym-tsk
-/homeassistant/components/starlink/ @boswelja
-/tests/components/starlink/ @boswelja
 /homeassistant/components/statistics/ @ThomDietrich @gjohansson-ST
 /tests/components/statistics/ @ThomDietrich @gjohansson-ST
 /homeassistant/components/steam_online/ @tkdrob

Dockerfile

@@ -10,7 +10,6 @@ LABEL \
     org.opencontainers.image.description="Open-source home automation platform running on Python 3" \
     org.opencontainers.image.documentation="https://www.home-assistant.io/docs/" \
     org.opencontainers.image.licenses="Apache-2.0" \
-    org.opencontainers.image.source="https://github.com/home-assistant/core" \
     org.opencontainers.image.title="Home Assistant" \
     org.opencontainers.image.url="https://www.home-assistant.io/"
 

homeassistant/components/actron_air/config_flow.py

@@ -120,7 +120,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_show_form(
                 step_id="timeout",
             )
-        del self.login_task
+        self.login_task = None
         return await self.async_step_user()
 
     async def async_step_reauth(

homeassistant/components/actron_air/manifest.json

@@ -12,6 +12,6 @@
   "documentation": "https://www.home-assistant.io/integrations/actron_air",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
+  "quality_scale": "silver",
   "requirements": ["actron-neo-api==0.4.1"]
 }

homeassistant/components/actron_air/quality_scale.yaml

@@ -37,7 +37,7 @@ rules:
   log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: done
-  test-coverage: todo
+  test-coverage: done
 
   # Gold
   devices: done

homeassistant/components/automation/__init__.py

@@ -123,16 +123,23 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "climate",
     "cover",
     "device_tracker",
+    "door",
     "fan",
+    "garage_door",
+    "gate",
     "humidifier",
     "lawn_mower",
     "light",
     "lock",
     "media_player",
+    "motion",
+    "occupancy",
     "person",
+    "schedule",
     "siren",
     "switch",
     "vacuum",
+    "window",
 }
 
 _EXPERIMENTAL_TRIGGER_PLATFORMS = {
@@ -143,6 +150,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "cover",
     "device_tracker",
     "door",
+    "event",
     "fan",
     "garage_door",
     "gate",
@@ -159,6 +167,7 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "remote",
     "scene",
     "schedule",
+    "select",
     "siren",
     "switch",
     "text",

homeassistant/components/axis/manifest.json

@@ -29,7 +29,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["axis"],
-  "requirements": ["axis==66"],
+  "requirements": ["axis==67"],
   "ssdp": [
     {
       "manufacturer": "AXIS"

homeassistant/components/backup/util.py

@@ -246,6 +246,8 @@ def decrypt_backup(
         except (DecryptError, SecureTarError, tarfile.TarError) as err:
             LOGGER.warning("Error decrypting backup: %s", err)
             error = err
+        except Abort:
+            raise
         except Exception as err:  # noqa: BLE001
             LOGGER.exception("Unexpected error when decrypting backup: %s", err)
             error = err
@@ -332,8 +334,10 @@ def encrypt_backup(
         except (EncryptError, SecureTarError, tarfile.TarError) as err:
             LOGGER.warning("Error encrypting backup: %s", err)
             error = err
+        except Abort:
+            raise
         except Exception as err:  # noqa: BLE001
-            LOGGER.exception("Unexpected error when decrypting backup: %s", err)
+            LOGGER.exception("Unexpected error when encrypting backup: %s", err)
             error = err
         else:
             # Pad the output stream to the requested minimum size

homeassistant/components/bsblan/config_flow.py

@@ -183,90 +183,122 @@ class BSBLANFlowHandler(ConfigFlow, domain=DOMAIN):
         existing_entry = self._get_reauth_entry()
 
         if user_input is None:
-            # Preserve existing values as defaults
             return self.async_show_form(
                 step_id="reauth_confirm",
-                data_schema=vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_PASSKEY,
-                            default=existing_entry.data.get(
-                                CONF_PASSKEY, vol.UNDEFINED
-                            ),
-                        ): str,
-                        vol.Optional(
-                            CONF_USERNAME,
-                            default=existing_entry.data.get(
-                                CONF_USERNAME, vol.UNDEFINED
-                            ),
-                        ): str,
-                        vol.Optional(
-                            CONF_PASSWORD,
-                            default=vol.UNDEFINED,
-                        ): str,
-                    }
-                ),
+                data_schema=self._build_credentials_schema(existing_entry.data),
             )
 
-        # Combine existing data with the user's new input for validation.
-        # This correctly handles adding, changing, and clearing credentials.
-        config_data = existing_entry.data.copy()
-        config_data.update(user_input)
+        # Merge existing data with user input for validation
+        validate_data = {**existing_entry.data, **user_input}
+        errors = await self._async_validate_credentials(validate_data)
 
-        self.host = config_data[CONF_HOST]
-        self.port = config_data[CONF_PORT]
-        self.passkey = config_data.get(CONF_PASSKEY)
-        self.username = config_data.get(CONF_USERNAME)
-        self.password = config_data.get(CONF_PASSWORD)
+        if errors:
+            return self.async_show_form(
+                step_id="reauth_confirm",
+                data_schema=self._build_credentials_schema(user_input),
+                errors=errors,
+            )
 
+        return self.async_update_reload_and_abort(
+            existing_entry, data_updates=user_input, reason="reauth_successful"
+        )
+
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration flow."""
+        existing_entry = self._get_reconfigure_entry()
+
+        if user_input is None:
+            return self.async_show_form(
+                step_id="reconfigure",
+                data_schema=self._build_connection_schema(existing_entry.data),
+            )
+
+        # Merge existing data with user input for validation
+        validate_data = {**existing_entry.data, **user_input}
+        errors = await self._async_validate_credentials(validate_data)
+
+        if errors:
+            return self.async_show_form(
+                step_id="reconfigure",
+                data_schema=self._build_connection_schema(user_input),
+                errors=errors,
+            )
+
+        # Prevent reconfiguring to a different physical device
+        # it gets the unique ID from the device info when it validates credentials
+        self._abort_if_unique_id_mismatch()
+
+        return self.async_update_reload_and_abort(
+            existing_entry,
+            data_updates=user_input,
+            reason="reconfigure_successful",
+        )
+
+    async def _async_validate_credentials(self, data: dict[str, Any]) -> dict[str, str]:
+        """Validate connection credentials and return errors dict."""
+        self.host = data[CONF_HOST]
+        self.port = data.get(CONF_PORT, DEFAULT_PORT)
+        self.passkey = data.get(CONF_PASSKEY)
+        self.username = data.get(CONF_USERNAME)
+        self.password = data.get(CONF_PASSWORD)
+
+        errors: dict[str, str] = {}
         try:
             await self._get_bsblan_info(raise_on_progress=False, is_reauth=True)
         except BSBLANAuthError:
-            return self.async_show_form(
-                step_id="reauth_confirm",
-                data_schema=vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_PASSKEY,
-                            default=user_input.get(CONF_PASSKEY, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_USERNAME,
-                            default=user_input.get(CONF_USERNAME, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_PASSWORD,
-                            default=vol.UNDEFINED,
-                        ): str,
-                    }
-                ),
-                errors={"base": "invalid_auth"},
-            )
+            errors["base"] = "invalid_auth"
         except BSBLANError:
-            return self.async_show_form(
-                step_id="reauth_confirm",
-                data_schema=vol.Schema(
-                    {
-                        vol.Optional(
-                            CONF_PASSKEY,
-                            default=user_input.get(CONF_PASSKEY, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_USERNAME,
-                            default=user_input.get(CONF_USERNAME, vol.UNDEFINED),
-                        ): str,
-                        vol.Optional(
-                            CONF_PASSWORD,
-                            default=vol.UNDEFINED,
-                        ): str,
-                    }
-                ),
-                errors={"base": "cannot_connect"},
-            )
+            errors["base"] = "cannot_connect"
+        return errors
 
-        # Update only the fields that were provided by the user
-        return self.async_update_reload_and_abort(
-            existing_entry, data_updates=user_input, reason="reauth_successful"
+    @callback
+    def _build_credentials_schema(self, defaults: Mapping[str, Any]) -> vol.Schema:
+        """Build schema for credentials-only forms (reauth)."""
+        return vol.Schema(
+            {
+                vol.Optional(
+                    CONF_PASSKEY,
+                    default=defaults.get(CONF_PASSKEY) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_USERNAME,
+                    default=defaults.get(CONF_USERNAME) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_PASSWORD,
+                    default=vol.UNDEFINED,
+                ): str,
+            }
+        )
+
+    @callback
+    def _build_connection_schema(self, defaults: Mapping[str, Any]) -> vol.Schema:
+        """Build schema for full connection forms (user and reconfigure)."""
+        return vol.Schema(
+            {
+                vol.Required(
+                    CONF_HOST,
+                    default=defaults.get(CONF_HOST, vol.UNDEFINED),
+                ): str,
+                vol.Optional(
+                    CONF_PORT,
+                    default=defaults.get(CONF_PORT, DEFAULT_PORT),
+                ): int,
+                vol.Optional(
+                    CONF_PASSKEY,
+                    default=defaults.get(CONF_PASSKEY) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_USERNAME,
+                    default=defaults.get(CONF_USERNAME) or vol.UNDEFINED,
+                ): str,
+                vol.Optional(
+                    CONF_PASSWORD,
+                    default=vol.UNDEFINED,
+                ): str,
+            }
         )
 
     @callback
@@ -274,32 +306,9 @@ class BSBLANFlowHandler(ConfigFlow, domain=DOMAIN):
         self, errors: dict | None = None, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Show the setup form to the user."""
-        # Preserve user input if provided, otherwise use defaults
-        defaults = user_input or {}
-
         return self.async_show_form(
             step_id="user",
-            data_schema=vol.Schema(
-                {
-                    vol.Required(
-                        CONF_HOST, default=defaults.get(CONF_HOST, vol.UNDEFINED)
-                    ): str,
-                    vol.Optional(
-                        CONF_PORT, default=defaults.get(CONF_PORT, DEFAULT_PORT)
-                    ): int,
-                    vol.Optional(
-                        CONF_PASSKEY, default=defaults.get(CONF_PASSKEY, vol.UNDEFINED)
-                    ): str,
-                    vol.Optional(
-                        CONF_USERNAME,
-                        default=defaults.get(CONF_USERNAME, vol.UNDEFINED),
-                    ): str,
-                    vol.Optional(
-                        CONF_PASSWORD,
-                        default=defaults.get(CONF_PASSWORD, vol.UNDEFINED),
-                    ): str,
-                }
-            ),
+            data_schema=self._build_connection_schema(user_input or {}),
             errors=errors or {},
         )
 

homeassistant/components/bsblan/quality_scale.yaml

@@ -58,7 +58,7 @@ rules:
   entity-translations: done
   exception-translations: done
   icon-translations: todo
-  reconfiguration-flow: todo
+  reconfiguration-flow: done
   repair-issues:
     status: exempt
     comment: |

homeassistant/components/bsblan/strings.json

@@ -3,7 +3,9 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
+      "unique_id_mismatch": "The device you are trying to reconfigure is not the same as the one previously configured."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -39,6 +41,24 @@
         "description": "The BSB-LAN integration needs to re-authenticate with {name}",
         "title": "[%key:common::config_flow::title::reauth%]"
       },
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "passkey": "[%key:component::bsblan::config::step::user::data::passkey%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "port": "[%key:common::config_flow::data::port%]",
+          "username": "[%key:common::config_flow::data::username%]"
+        },
+        "data_description": {
+          "host": "[%key:component::bsblan::config::step::user::data_description::host%]",
+          "passkey": "[%key:component::bsblan::config::step::user::data_description::passkey%]",
+          "password": "[%key:component::bsblan::config::step::user::data_description::password%]",
+          "port": "[%key:component::bsblan::config::step::user::data_description::port%]",
+          "username": "[%key:component::bsblan::config::step::user::data_description::username%]"
+        },
+        "description": "Update connection settings for your BSB-LAN device.",
+        "title": "Reconfigure BSB-LAN"
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",

homeassistant/components/clementine/media_player.py

@@ -66,6 +66,7 @@ class ClementineDevice(MediaPlayerEntity):
         | MediaPlayerEntityFeature.SELECT_SOURCE
         | MediaPlayerEntityFeature.PLAY
     )
+    _attr_volume_step = 0.04
 
     def __init__(self, client, name):
         """Initialize the Clementine device."""
@@ -124,16 +125,6 @@ class ClementineDevice(MediaPlayerEntity):
 
         return None, None
 
-    def volume_up(self) -> None:
-        """Volume up the media player."""
-        newvolume = min(self._client.volume + 4, 100)
-        self._client.set_volume(newvolume)
-
-    def volume_down(self) -> None:
-        """Volume down media player."""
-        newvolume = max(self._client.volume - 4, 0)
-        self._client.set_volume(newvolume)
-
     def mute_volume(self, mute: bool) -> None:
         """Send mute command."""
         self._client.set_volume(0)

homeassistant/components/cover/__init__.py

@@ -32,6 +32,7 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 from homeassistant.util.hass_dict import HassKey
 
+from .condition import make_cover_is_closed_condition, make_cover_is_open_condition
 from .const import (
     ATTR_CURRENT_POSITION,
     ATTR_CURRENT_TILT_POSITION,
@@ -80,6 +81,8 @@ __all__ = [
     "CoverEntityFeature",
     "CoverState",
     "make_cover_closed_trigger",
+    "make_cover_is_closed_condition",
+    "make_cover_is_open_condition",
     "make_cover_opened_trigger",
 ]
 

homeassistant/components/door/condition.py

@@ -0,0 +1,29 @@
+"""Provides conditions for doors."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_is_closed_condition,
+    make_cover_is_open_condition,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition
+
+DEVICE_CLASSES_DOOR: dict[str, str] = {
+    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.DOOR,
+    COVER_DOMAIN: CoverDeviceClass.DOOR,
+}
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_closed": make_cover_is_closed_condition(device_classes=DEVICE_CLASSES_DOOR),
+    "is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_DOOR),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for doors."""
+    return CONDITIONS

homeassistant/components/door/conditions.yaml

@@ -0,0 +1,28 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_closed:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: door
+      - domain: cover
+        device_class: door
+
+is_open:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: door
+      - domain: cover
+        device_class: door

homeassistant/components/door/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_closed": {
+      "condition": "mdi:door-closed"
+    },
+    "is_open": {
+      "condition": "mdi:door-open"
+    }
+  },
   "triggers": {
     "closed": {
       "trigger": "mdi:door-closed"

homeassistant/components/door/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted doors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted doors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_closed": {
+      "description": "Tests if one or more doors are closed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::door::common::condition_behavior_description%]",
+          "name": "[%key:component::door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Door is closed"
+    },
+    "is_open": {
+      "description": "Tests if one or more doors are open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::door::common::condition_behavior_description%]",
+          "name": "[%key:component::door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Door is open"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/dropbox/__init__.py

@@ -0,0 +1,64 @@
+"""The Dropbox integration."""
+
+from __future__ import annotations
+
+from python_dropbox_api import (
+    DropboxAPIClient,
+    DropboxAuthException,
+    DropboxUnknownException,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers import aiohttp_client
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    ImplementationUnavailableError,
+    OAuth2Session,
+    async_get_config_entry_implementation,
+)
+
+from .auth import DropboxConfigEntryAuth
+from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+
+type DropboxConfigEntry = ConfigEntry[DropboxAPIClient]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: DropboxConfigEntry) -> bool:
+    """Set up Dropbox from a config entry."""
+    try:
+        oauth2_implementation = await async_get_config_entry_implementation(hass, entry)
+    except ImplementationUnavailableError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="oauth2_implementation_unavailable",
+        ) from err
+    oauth2_session = OAuth2Session(hass, entry, oauth2_implementation)
+
+    auth = DropboxConfigEntryAuth(
+        aiohttp_client.async_get_clientsession(hass), oauth2_session
+    )
+
+    client = DropboxAPIClient(auth)
+
+    try:
+        await client.get_account_info()
+    except DropboxAuthException as err:
+        raise ConfigEntryAuthFailed from err
+    except (DropboxUnknownException, TimeoutError) as err:
+        raise ConfigEntryNotReady from err
+
+    entry.runtime_data = 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: DropboxConfigEntry) -> bool:
+    """Unload a config entry."""
+    return True

homeassistant/components/dropbox/application_credentials.py

@@ -0,0 +1,38 @@
+"""Application credentials platform for the Dropbox integration."""
+
+from homeassistant.components.application_credentials import ClientCredential
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.config_entry_oauth2_flow import (
+    AbstractOAuth2Implementation,
+    LocalOAuth2ImplementationWithPkce,
+)
+
+from .const import OAUTH2_AUTHORIZE, OAUTH2_SCOPES, OAUTH2_TOKEN
+
+
+async def async_get_auth_implementation(
+    hass: HomeAssistant, auth_domain: str, credential: ClientCredential
+) -> AbstractOAuth2Implementation:
+    """Return custom auth implementation."""
+    return DropboxOAuth2Implementation(
+        hass,
+        auth_domain,
+        credential.client_id,
+        OAUTH2_AUTHORIZE,
+        OAUTH2_TOKEN,
+        credential.client_secret,
+    )
+
+
+class DropboxOAuth2Implementation(LocalOAuth2ImplementationWithPkce):
+    """Custom Dropbox OAuth2 implementation to add the necessary authorize url parameters."""
+
+    @property
+    def extra_authorize_data(self) -> dict:
+        """Extra data that needs to be appended to the authorize url."""
+        data: dict = {
+            "token_access_type": "offline",
+            "scope": " ".join(OAUTH2_SCOPES),
+        }
+        data.update(super().extra_authorize_data)
+        return data

homeassistant/components/dropbox/auth.py

@@ -0,0 +1,44 @@
+"""Authentication for Dropbox."""
+
+from typing import cast
+
+from aiohttp import ClientSession
+from python_dropbox_api import Auth
+
+from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
+
+
+class DropboxConfigEntryAuth(Auth):
+    """Provide Dropbox authentication tied to an OAuth2 based config entry."""
+
+    def __init__(
+        self,
+        websession: ClientSession,
+        oauth_session: OAuth2Session,
+    ) -> None:
+        """Initialize DropboxConfigEntryAuth."""
+        super().__init__(websession)
+        self._oauth_session = oauth_session
+
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+        await self._oauth_session.async_ensure_token_valid()
+
+        return cast(str, self._oauth_session.token["access_token"])
+
+
+class DropboxConfigFlowAuth(Auth):
+    """Provide authentication tied to a fixed token for the config flow."""
+
+    def __init__(
+        self,
+        websession: ClientSession,
+        token: str,
+    ) -> None:
+        """Initialize DropboxConfigFlowAuth."""
+        super().__init__(websession)
+        self._token = token
+
+    async def async_get_access_token(self) -> str:
+        """Return the fixed access token."""
+        return self._token

homeassistant/components/dropbox/backup.py

@@ -0,0 +1,230 @@
+"""Backup platform for the Dropbox integration."""
+
+from collections.abc import AsyncIterator, Callable, Coroutine
+from functools import wraps
+import json
+import logging
+from typing import Any, Concatenate
+
+from python_dropbox_api import (
+    DropboxAPIClient,
+    DropboxAuthException,
+    DropboxFileOrFolderNotFoundException,
+    DropboxUnknownException,
+)
+
+from homeassistant.components.backup import (
+    AgentBackup,
+    BackupAgent,
+    BackupAgentError,
+    BackupNotFound,
+    suggested_filename,
+)
+from homeassistant.core import HomeAssistant, callback
+
+from . import DropboxConfigEntry
+from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _suggested_filenames(backup: AgentBackup) -> tuple[str, str]:
+    """Return the suggested filenames for the backup and metadata."""
+    base_name = suggested_filename(backup).rsplit(".", 1)[0]
+    return f"{base_name}.tar", f"{base_name}.metadata.json"
+
+
+async def _async_string_iterator(content: str) -> AsyncIterator[bytes]:
+    """Yield a string as a single bytes chunk."""
+    yield content.encode()
+
+
+def handle_backup_errors[_R, **P](
+    func: Callable[Concatenate[DropboxBackupAgent, P], Coroutine[Any, Any, _R]],
+) -> Callable[Concatenate[DropboxBackupAgent, P], Coroutine[Any, Any, _R]]:
+    """Handle backup errors."""
+
+    @wraps(func)
+    async def wrapper(
+        self: DropboxBackupAgent, *args: P.args, **kwargs: P.kwargs
+    ) -> _R:
+        try:
+            return await func(self, *args, **kwargs)
+        except DropboxFileOrFolderNotFoundException as err:
+            raise BackupNotFound(
+                f"Failed to {func.__name__.removeprefix('async_').replace('_', ' ')}"
+            ) from err
+        except DropboxAuthException as err:
+            self._entry.async_start_reauth(self._hass)
+            raise BackupAgentError("Authentication error") from err
+        except DropboxUnknownException as err:
+            _LOGGER.error(
+                "Error during %s: %s",
+                func.__name__,
+                err,
+            )
+            _LOGGER.debug("Full error: %s", err, exc_info=True)
+            raise BackupAgentError(
+                f"Failed to {func.__name__.removeprefix('async_').replace('_', ' ')}"
+            ) from err
+
+    return wrapper
+
+
+async def async_get_backup_agents(
+    hass: HomeAssistant,
+    **kwargs: Any,
+) -> list[BackupAgent]:
+    """Return a list of backup agents."""
+    entries = hass.config_entries.async_loaded_entries(DOMAIN)
+    return [DropboxBackupAgent(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.
+
+    :return: A function to unregister the listener.
+    """
+    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]:
+            del hass.data[DATA_BACKUP_AGENT_LISTENERS]
+
+    return remove_listener
+
+
+class DropboxBackupAgent(BackupAgent):
+    """Backup agent for the Dropbox integration."""
+
+    domain = DOMAIN
+
+    def __init__(self, hass: HomeAssistant, entry: DropboxConfigEntry) -> None:
+        """Initialize the backup agent."""
+        super().__init__()
+        self._hass = hass
+        self._entry = entry
+        self.name = entry.title
+        assert entry.unique_id
+        self.unique_id = entry.unique_id
+        self._api: DropboxAPIClient = entry.runtime_data
+
+    async def _async_get_backups(self) -> list[tuple[AgentBackup, str]]:
+        """Get backups and their corresponding file names."""
+        files = await self._api.list_folder("")
+
+        tar_files = {f.name for f in files if f.name.endswith(".tar")}
+        metadata_files = [f for f in files if f.name.endswith(".metadata.json")]
+
+        backups: list[tuple[AgentBackup, str]] = []
+        for metadata_file in metadata_files:
+            tar_name = metadata_file.name.removesuffix(".metadata.json") + ".tar"
+            if tar_name not in tar_files:
+                _LOGGER.warning(
+                    "Found metadata file '%s' without matching backup file",
+                    metadata_file.name,
+                )
+                continue
+
+            metadata_stream = self._api.download_file(f"/{metadata_file.name}")
+            raw = b"".join([chunk async for chunk in metadata_stream])
+            try:
+                data = json.loads(raw)
+                backup = AgentBackup.from_dict(data)
+            except (json.JSONDecodeError, ValueError, TypeError, KeyError) as err:
+                _LOGGER.warning(
+                    "Skipping invalid metadata file '%s': %s",
+                    metadata_file.name,
+                    err,
+                )
+                continue
+            backups.append((backup, tar_name))
+
+        return backups
+
+    @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."""
+        backup_filename, metadata_filename = _suggested_filenames(backup)
+        backup_path = f"/{backup_filename}"
+        metadata_path = f"/{metadata_filename}"
+
+        file_stream = await open_stream()
+        await self._api.upload_file(backup_path, file_stream)
+
+        metadata_stream = _async_string_iterator(json.dumps(backup.as_dict()))
+
+        try:
+            await self._api.upload_file(metadata_path, metadata_stream)
+        except (
+            DropboxAuthException,
+            DropboxUnknownException,
+        ):
+            await self._api.delete_file(backup_path)
+            raise
+
+    @handle_backup_errors
+    async def async_list_backups(self, **kwargs: Any) -> list[AgentBackup]:
+        """List backups."""
+        return [backup for backup, _ in await self._async_get_backups()]
+
+    @handle_backup_errors
+    async def async_download_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> AsyncIterator[bytes]:
+        """Download a backup file."""
+        backups = await self._async_get_backups()
+        for backup, filename in backups:
+            if backup.backup_id == backup_id:
+                return self._api.download_file(f"/{filename}")
+
+        raise BackupNotFound(f"Backup {backup_id} not found")
+
+    @handle_backup_errors
+    async def async_get_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> AgentBackup:
+        """Return a backup."""
+        backups = await self._async_get_backups()
+
+        for backup, _ in backups:
+            if backup.backup_id == backup_id:
+                return backup
+
+        raise BackupNotFound(f"Backup {backup_id} not found")
+
+    @handle_backup_errors
+    async def async_delete_backup(
+        self,
+        backup_id: str,
+        **kwargs: Any,
+    ) -> None:
+        """Delete a backup file."""
+        backups = await self._async_get_backups()
+        for backup, tar_filename in backups:
+            if backup.backup_id == backup_id:
+                metadata_filename = tar_filename.removesuffix(".tar") + ".metadata.json"
+                await self._api.delete_file(f"/{tar_filename}")
+                await self._api.delete_file(f"/{metadata_filename}")
+                return
+
+        raise BackupNotFound(f"Backup {backup_id} not found")

homeassistant/components/dropbox/config_flow.py

@@ -0,0 +1,60 @@
+"""Config flow for Dropbox."""
+
+from collections.abc import Mapping
+import logging
+from typing import Any
+
+from python_dropbox_api import DropboxAPIClient
+
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
+
+from .auth import DropboxConfigFlowAuth
+from .const import DOMAIN
+
+
+class DropboxConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
+    """Config flow to handle Dropbox OAuth2 authentication."""
+
+    DOMAIN = DOMAIN
+
+    @property
+    def logger(self) -> logging.Logger:
+        """Return logger."""
+        return logging.getLogger(__name__)
+
+    async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
+        """Create an entry for the flow, or update existing entry."""
+        access_token = data[CONF_TOKEN][CONF_ACCESS_TOKEN]
+
+        auth = DropboxConfigFlowAuth(async_get_clientsession(self.hass), access_token)
+
+        client = DropboxAPIClient(auth)
+        account_info = await client.get_account_info()
+
+        await self.async_set_unique_id(account_info.account_id)
+        if self.source == SOURCE_REAUTH:
+            self._abort_if_unique_id_mismatch(reason="wrong_account")
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(), data=data
+            )
+
+        self._abort_if_unique_id_configured()
+
+        return self.async_create_entry(title=account_info.email, data=data)
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Dialog that informs the user that reauth is required."""
+        if user_input is None:
+            return self.async_show_form(step_id="reauth_confirm")
+        return await self.async_step_user()

homeassistant/components/dropbox/const.py

@@ -0,0 +1,19 @@
+"""Constants for the Dropbox integration."""
+
+from collections.abc import Callable
+
+from homeassistant.util.hass_dict import HassKey
+
+DOMAIN = "dropbox"
+
+OAUTH2_AUTHORIZE = "https://www.dropbox.com/oauth2/authorize"
+OAUTH2_TOKEN = "https://api.dropboxapi.com/oauth2/token"
+OAUTH2_SCOPES = [
+    "account_info.read",
+    "files.content.read",
+    "files.content.write",
+]
+
+DATA_BACKUP_AGENT_LISTENERS: HassKey[list[Callable[[], None]]] = HassKey(
+    f"{DOMAIN}.backup_agent_listeners"
+)

homeassistant/components/dropbox/manifest.json

@@ -0,0 +1,13 @@
+{
+  "domain": "dropbox",
+  "name": "Dropbox",
+  "after_dependencies": ["backup"],
+  "codeowners": ["@bdr99"],
+  "config_flow": true,
+  "dependencies": ["application_credentials"],
+  "documentation": "https://www.home-assistant.io/integrations/dropbox",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["python-dropbox-api==0.1.3"]
+}

homeassistant/components/dropbox/quality_scale.yaml

@@ -0,0 +1,112 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register any actions.
+  appropriate-polling:
+    status: exempt
+    comment: Integration does not poll.
+  brands: done
+  common-modules:
+    status: exempt
+    comment: Integration does not have any entities or coordinators.
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: Integration does not register any actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-unique-id:
+    status: exempt
+    comment: Integration does not have any entities.
+  has-entity-name:
+    status: exempt
+    comment: Integration does not have any entities.
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: Integration does not register any actions.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: Integration does not have any configuration parameters.
+  docs-installation-parameters: done
+  entity-unavailable:
+    status: exempt
+    comment: Integration does not have any entities.
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates:
+    status: exempt
+    comment: Integration does not make any entity updates.
+  reauthentication-flow: done
+  test-coverage: done
+
+  # Gold
+  devices:
+    status: exempt
+    comment: Integration does not have any entities.
+  diagnostics:
+    status: exempt
+    comment: Integration does not have any data to diagnose.
+  discovery-update-info:
+    status: exempt
+    comment: Integration is a service.
+  discovery:
+    status: exempt
+    comment: Integration is a service.
+  docs-data-update:
+    status: exempt
+    comment: Integration does not update any data.
+  docs-examples:
+    status: exempt
+    comment: Integration only provides backup functionality.
+  docs-known-limitations: todo
+  docs-supported-devices:
+    status: exempt
+    comment: Integration does not support any devices.
+  docs-supported-functions: done
+  docs-troubleshooting: todo
+  docs-use-cases: done
+  dynamic-devices:
+    status: exempt
+    comment: Integration does not use any devices.
+  entity-category:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-device-class:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-disabled-by-default:
+    status: exempt
+    comment: Integration does not have any entities.
+  entity-translations:
+    status: exempt
+    comment: Integration does not have any entities.
+  exception-translations: todo
+  icon-translations:
+    status: exempt
+    comment: Integration does not have any entities.
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: Integration does not have any repairs.
+  stale-devices:
+    status: exempt
+    comment: Integration does not have any devices.
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/components/dropbox/strings.json

@@ -0,0 +1,35 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
+      "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
+      "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
+      "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",
+      "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
+      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
+      "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
+      "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "user_rejected_authorize": "[%key:common::config_flow::abort::oauth2_user_rejected_authorize%]",
+      "wrong_account": "Wrong account: Please authenticate with the correct account."
+    },
+    "create_entry": {
+      "default": "[%key:common::config_flow::create_entry::authenticated%]"
+    },
+    "step": {
+      "pick_implementation": {
+        "title": "[%key:common::config_flow::title::oauth2_pick_implementation%]"
+      },
+      "reauth_confirm": {
+        "description": "The Dropbox integration needs to re-authenticate your account.",
+        "title": "[%key:common::config_flow::title::reauth%]"
+      }
+    }
+  },
+  "exceptions": {
+    "oauth2_implementation_unavailable": {
+      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+    }
+  }
+}

homeassistant/components/event/icons.json

@@ -12,5 +12,10 @@
     "motion": {
       "default": "mdi:motion-sensor"
     }
+  },
+  "triggers": {
+    "received": {
+      "trigger": "mdi:eye-check"
+    }
   }
 }

homeassistant/components/event/strings.json

@@ -21,5 +21,17 @@
       "name": "Motion"
     }
   },
-  "title": "Event"
+  "title": "Event",
+  "triggers": {
+    "received": {
+      "description": "Triggers after one or more event entities receive a matching event.",
+      "fields": {
+        "event_type": {
+          "description": "The event types to trigger on.",
+          "name": "Event type"
+        }
+      },
+      "name": "Event received"
+    }
+  }
 }

homeassistant/components/event/trigger.py

@@ -0,0 +1,67 @@
+"""Provides triggers for events."""
+
+import voluptuous as vol
+
+from homeassistant.const import CONF_OPTIONS, STATE_UNAVAILABLE, STATE_UNKNOWN
+from homeassistant.core import HomeAssistant, State
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.trigger import (
+    ENTITY_STATE_TRIGGER_SCHEMA,
+    EntityTriggerBase,
+    Trigger,
+    TriggerConfig,
+)
+
+from .const import ATTR_EVENT_TYPE, DOMAIN
+
+CONF_EVENT_TYPE = "event_type"
+
+EVENT_RECEIVED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA.extend(
+    {
+        vol.Required(CONF_OPTIONS): {
+            vol.Required(CONF_EVENT_TYPE): vol.All(
+                cv.ensure_list, vol.Length(min=1), [cv.string]
+            ),
+        },
+    }
+)
+
+
+class EventReceivedTrigger(EntityTriggerBase):
+    """Trigger for event entity when it receives a matching event."""
+
+    _domain_specs = {DOMAIN: DomainSpec()}
+    _schema = EVENT_RECEIVED_TRIGGER_SCHEMA
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize the event received trigger."""
+        super().__init__(hass, config)
+        self._event_types = set(self._options[CONF_EVENT_TYPE])
+
+    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
+        """Check if the origin state is valid and different from the current state."""
+
+        # UNKNOWN is a valid from_state, otherwise the first time the event is received
+        # would not trigger
+        if from_state.state == STATE_UNAVAILABLE:
+            return False
+
+        return from_state.state != to_state.state
+
+    def is_valid_state(self, state: State) -> bool:
+        """Check if the event type is valid and matches one of the configured types."""
+        return (
+            state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
+            and state.attributes.get(ATTR_EVENT_TYPE) in self._event_types
+        )
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "received": EventReceivedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for events."""
+    return TRIGGERS

homeassistant/components/event/triggers.yaml

@@ -0,0 +1,16 @@
+received:
+  target:
+    entity:
+      domain: event
+  fields:
+    event_type:
+      context:
+        filter_target: target
+      required: true
+      selector:
+        state:
+          attribute: event_type
+          hide_states:
+            - unavailable
+            - unknown
+          multiple: true

homeassistant/components/fully_kiosk/button.py

@@ -27,6 +27,7 @@ class FullyButtonEntityDescription(ButtonEntityDescription):
     """Fully Kiosk Browser button description."""
 
     press_action: Callable[[FullyKiosk], Any]
+    refresh_after_press: bool = True
 
 
 BUTTONS: tuple[FullyButtonEntityDescription, ...] = (
@@ -68,6 +69,13 @@ BUTTONS: tuple[FullyButtonEntityDescription, ...] = (
         entity_category=EntityCategory.CONFIG,
         press_action=lambda fully: fully.clearCache(),
     ),
+    FullyButtonEntityDescription(
+        key="triggerMotion",
+        translation_key="trigger_motion",
+        entity_category=EntityCategory.CONFIG,
+        press_action=lambda fully: fully.triggerMotion(),
+        refresh_after_press=False,
+    ),
 )
 
 
@@ -102,4 +110,5 @@ class FullyButtonEntity(FullyKioskEntity, ButtonEntity):
     async def async_press(self) -> None:
         """Set the value of the entity."""
         await self.entity_description.press_action(self.coordinator.fully)
-        await self.coordinator.async_refresh()
+        if self.entity_description.refresh_after_press:
+            await self.coordinator.async_refresh()

homeassistant/components/fully_kiosk/sensor.py

@@ -12,7 +12,12 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfInformation
+from homeassistant.const import (
+    PERCENTAGE,
+    EntityCategory,
+    UnitOfInformation,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -56,6 +61,14 @@ SENSORS: tuple[FullySensorEntityDescription, ...] = (
         state_class=SensorStateClass.MEASUREMENT,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
+    FullySensorEntityDescription(
+        key="batteryTemperature",
+        translation_key="battery_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
     FullySensorEntityDescription(
         key="currentPage",
         translation_key="current_page",

homeassistant/components/fully_kiosk/strings.json

@@ -88,6 +88,9 @@
       },
       "to_foreground": {
         "name": "Bring to foreground"
+      },
+      "trigger_motion": {
+        "name": "Trigger motion activity"
       }
     },
     "image": {
@@ -118,6 +121,9 @@
       }
     },
     "sensor": {
+      "battery_temperature": {
+        "name": "Battery temperature"
+      },
       "current_page": {
         "name": "Current page"
       },

homeassistant/components/garage_door/condition.py

@@ -0,0 +1,31 @@
+"""Provides conditions for garage doors."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_is_closed_condition,
+    make_cover_is_open_condition,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition
+
+DEVICE_CLASSES_GARAGE_DOOR: dict[str, str] = {
+    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.GARAGE_DOOR,
+    COVER_DOMAIN: CoverDeviceClass.GARAGE,
+}
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_closed": make_cover_is_closed_condition(
+        device_classes=DEVICE_CLASSES_GARAGE_DOOR
+    ),
+    "is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_GARAGE_DOOR),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for garage doors."""
+    return CONDITIONS

homeassistant/components/garage_door/conditions.yaml

@@ -0,0 +1,28 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_closed:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: garage_door
+      - domain: cover
+        device_class: garage
+
+is_open:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: garage_door
+      - domain: cover
+        device_class: garage

homeassistant/components/garage_door/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_closed": {
+      "condition": "mdi:garage"
+    },
+    "is_open": {
+      "condition": "mdi:garage-open"
+    }
+  },
   "triggers": {
     "closed": {
       "trigger": "mdi:garage"

homeassistant/components/garage_door/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted garage doors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted garage doors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_closed": {
+      "description": "Tests if one or more garage doors are closed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::garage_door::common::condition_behavior_description%]",
+          "name": "[%key:component::garage_door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Garage door is closed"
+    },
+    "is_open": {
+      "description": "Tests if one or more garage doors are open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::garage_door::common::condition_behavior_description%]",
+          "name": "[%key:component::garage_door::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Garage door is open"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/gate/condition.py

@@ -0,0 +1,24 @@
+"""Provides conditions for gates."""
+
+from homeassistant.components.cover import (
+    DOMAIN as COVER_DOMAIN,
+    CoverDeviceClass,
+    make_cover_is_closed_condition,
+    make_cover_is_open_condition,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition
+
+DEVICE_CLASSES_GATE: dict[str, str] = {
+    COVER_DOMAIN: CoverDeviceClass.GATE,
+}
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_closed": make_cover_is_closed_condition(device_classes=DEVICE_CLASSES_GATE),
+    "is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_GATE),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for gates."""
+    return CONDITIONS

homeassistant/components/gate/conditions.yaml

@@ -0,0 +1,24 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_closed:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: gate
+
+is_open:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: cover
+        device_class: gate

homeassistant/components/gate/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_closed": {
+      "condition": "mdi:gate"
+    },
+    "is_open": {
+      "condition": "mdi:gate-open"
+    }
+  },
   "triggers": {
     "closed": {
       "trigger": "mdi:gate"

homeassistant/components/gate/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted gates.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted gates to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_closed": {
+      "description": "Tests if one or more gates are closed.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::gate::common::condition_behavior_description%]",
+          "name": "[%key:component::gate::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Gate is closed"
+    },
+    "is_open": {
+      "description": "Tests if one or more gates are open.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::gate::common::condition_behavior_description%]",
+          "name": "[%key:component::gate::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Gate is open"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/google_drive/__init__.py

@@ -12,6 +12,7 @@ from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import instance_id
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import (
+    ImplementationUnavailableError,
     OAuth2Session,
     async_get_config_entry_implementation,
 )
@@ -30,11 +31,17 @@ _PLATFORMS = (Platform.SENSOR,)
 
 async def async_setup_entry(hass: HomeAssistant, entry: GoogleDriveConfigEntry) -> bool:
     """Set up Google Drive from a config entry."""
+    try:
+        implementation = await async_get_config_entry_implementation(hass, entry)
+    except ImplementationUnavailableError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="oauth2_implementation_unavailable",
+        ) from err
+
     auth = AsyncConfigEntryAuth(
         async_get_clientsession(hass),
-        OAuth2Session(
-            hass, entry, await async_get_config_entry_implementation(hass, entry)
-        ),
+        OAuth2Session(hass, entry, implementation),
     )
 
     # Test we can refresh the token and raise ConfigEntryAuthFailed or ConfigEntryNotReady if not
@@ -46,7 +53,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: GoogleDriveConfigEntry)
     try:
         folder_id, _ = await client.async_create_ha_root_folder_if_not_exists()
     except GoogleDriveApiError as err:
-        raise ConfigEntryNotReady from err
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="failed_to_get_folder",
+            translation_placeholders={"folder": "Home Assistant"},
+        ) from err
 
     def async_notify_backup_listeners() -> None:
         for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):

homeassistant/components/google_drive/api.py

@@ -22,6 +22,8 @@ from homeassistant.exceptions import (
 )
 from homeassistant.helpers import config_entry_oauth2_flow
 
+from .const import DOMAIN
+
 _UPLOAD_AND_DOWNLOAD_TIMEOUT = 12 * 3600
 _UPLOAD_MAX_RETRIES = 20
 
@@ -61,14 +63,21 @@ class AsyncConfigEntryAuth(AbstractAuth):
             ):
                 if isinstance(ex, ClientResponseError) and 400 <= ex.status < 500:
                     raise ConfigEntryAuthFailed(
-                        "OAuth session is not valid, reauth required"
+                        translation_domain=DOMAIN,
+                        translation_key="authentication_not_valid",
                     ) from ex
-                raise ConfigEntryNotReady from ex
+                raise ConfigEntryNotReady(
+                    translation_domain=DOMAIN,
+                    translation_key="authentication_failed",
+                ) from ex
             if hasattr(ex, "status") and ex.status == 400:
                 self._oauth_session.config_entry.async_start_reauth(
                     self._oauth_session.hass
                 )
-            raise HomeAssistantError(ex) from ex
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="authentication_failed",
+            ) from ex
         return str(self._oauth_session.token[CONF_ACCESS_TOKEN])
 
 

homeassistant/components/google_drive/quality_scale.yaml

@@ -17,9 +17,7 @@ rules:
   docs-removal-instructions: done
   entity-event-setup: done
   entity-unique-id: done
-  has-entity-name:
-    status: exempt
-    comment: No entities.
+  has-entity-name: done
   runtime-data: done
   test-before-configure: done
   test-before-setup: done
@@ -66,9 +64,7 @@ rules:
   entity-disabled-by-default: done
   entity-translations: done
   exception-translations: done
-  icon-translations:
-    status: exempt
-    comment: No entities.
+  icon-translations: done
   reconfiguration-flow:
     status: exempt
     comment: No configuration options.

homeassistant/components/google_drive/strings.json

@@ -62,5 +62,22 @@
         "name": "Used storage in Drive Trash"
       }
     }
+  },
+  "exceptions": {
+    "authentication_failed": {
+      "message": "Authentication failed"
+    },
+    "authentication_not_valid": {
+      "message": "OAuth session is not valid, reauth required"
+    },
+    "failed_to_get_folder": {
+      "message": "Failed to get {folder} folder"
+    },
+    "invalid_response_google_drive_error": {
+      "message": "Invalid response from Google Drive: {error}"
+    },
+    "oauth2_implementation_unavailable": {
+      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
+    }
   }
 }

homeassistant/components/growatt_server/coordinator.py

@@ -251,7 +251,7 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
     def get_data(
         self, entity_description: GrowattSensorEntityDescription
-    ) -> str | int | float | None:
+    ) -> str | int | float | datetime.datetime | datetime.date | None:
         """Get the data."""
         variable = entity_description.api_key
         api_value = self.data.get(variable)

homeassistant/components/growatt_server/icons.json

@@ -1,4 +1,17 @@
 {
+  "entity": {
+    "sensor": {
+      "storage_load_consumption_solar_storage": {
+        "default": "mdi:lightning-bolt"
+      },
+      "total_money_today": {
+        "default": "mdi:cash"
+      },
+      "total_money_total": {
+        "default": "mdi:cash"
+      }
+    }
+  },
   "services": {
     "read_ac_charge_times": {
       "service": "mdi:battery-clock-outline"

homeassistant/components/growatt_server/number.py

@@ -17,7 +17,6 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
-from .sensor.sensor_entity_description import GrowattRequiredKeysMixin
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -27,9 +26,10 @@ PARALLEL_UPDATES = (
 
 
 @dataclass(frozen=True, kw_only=True)
-class GrowattNumberEntityDescription(NumberEntityDescription, GrowattRequiredKeysMixin):
+class GrowattNumberEntityDescription(NumberEntityDescription):
     """Describes Growatt number entity."""
 
+    api_key: str
     write_key: str | None = None  # Parameter ID for writing (if different from api_key)
 
 
@@ -130,6 +130,7 @@ class GrowattNumber(CoordinatorEntity[GrowattCoordinator], NumberEntity):
             identifiers={(DOMAIN, coordinator.device_id)},
             manufacturer="Growatt",
             name=coordinator.device_id,
+            serial_number=coordinator.device_id,
         )
 
     @property

homeassistant/components/growatt_server/quality_scale.yaml

@@ -32,9 +32,7 @@ rules:
   test-coverage: done
 
   # Gold
-  devices:
-    status: todo
-    comment: Add serial_number field to DeviceInfo in sensor, number, and switch platforms using device_id/serial_id.
+  devices: done
   diagnostics: todo
   discovery-update-info: todo
   discovery: todo
@@ -46,16 +44,12 @@ rules:
   docs-troubleshooting: todo
   docs-use-cases: todo
   dynamic-devices: todo
-  entity-category:
-    status: todo
-    comment: Add EntityCategory.DIAGNOSTIC to temperature and other diagnostic sensors. Merge GrowattRequiredKeysMixin into GrowattSensorEntityDescription using kw_only=True.
-  entity-device-class:
-    status: todo
-    comment: Replace custom precision field with suggested_display_precision to preserve full data granularity.
-  entity-disabled-by-default: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: done
   entity-translations: done
   exception-translations: todo
-  icon-translations: todo
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/growatt_server/sensor/__init__.py

@@ -2,12 +2,14 @@
 
 from __future__ import annotations
 
+from datetime import date, datetime
 import logging
 
 from homeassistant.components.sensor import SensorEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from ..const import DOMAIN
@@ -99,24 +101,18 @@ class GrowattSensor(CoordinatorEntity[GrowattCoordinator], SensorEntity):
         self.entity_description = description
 
         self._attr_unique_id = unique_id
-        self._attr_icon = "mdi:solar-power"
 
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, serial_id)},
             manufacturer="Growatt",
             name=name,
+            serial_number=serial_id,
         )
 
     @property
-    def native_value(self) -> str | int | float | None:
+    def native_value(self) -> StateType | date | datetime:
         """Return the state of the sensor."""
-        result = self.coordinator.get_data(self.entity_description)
-        if (
-            isinstance(result, (int, float))
-            and self.entity_description.precision is not None
-        ):
-            result = round(result, self.entity_description.precision)
-        return result
+        return self.coordinator.get_data(self.entity_description)
 
     @property
     def native_unit_of_measurement(self) -> str | None:

homeassistant/components/growatt_server/sensor/inverter.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
+    EntityCategory,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
     UnitOfEnergy,
@@ -22,7 +23,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_energy_total",
@@ -30,7 +31,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="powerTotal",
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
-        precision=1,
+        suggested_display_precision=1,
         state_class=SensorStateClass.TOTAL,
     ),
     GrowattSensorEntityDescription(
@@ -40,7 +41,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="inverter_amperage_input_1",
@@ -49,7 +50,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_wattage_input_1",
@@ -58,7 +59,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_voltage_input_2",
@@ -67,7 +68,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_amperage_input_2",
@@ -76,7 +77,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_wattage_input_2",
@@ -85,7 +86,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_voltage_input_3",
@@ -94,7 +95,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_amperage_input_3",
@@ -103,7 +104,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_wattage_input_3",
@@ -112,7 +113,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_internal_wattage",
@@ -121,7 +122,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_reactive_voltage",
@@ -130,7 +131,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_inverter_reactive_amperage",
@@ -139,7 +142,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_frequency",
@@ -148,7 +153,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_current_wattage",
@@ -157,7 +164,7 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="inverter_current_reactive_wattage",
@@ -166,7 +173,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_ipm_temperature",
@@ -175,7 +184,9 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="inverter_temperature",
@@ -184,6 +195,8 @@ INVERTER_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
 )

homeassistant/components/growatt_server/sensor/sensor_entity_description.py

@@ -7,18 +7,11 @@ from dataclasses import dataclass
 from homeassistant.components.sensor import SensorEntityDescription
 
 
-@dataclass(frozen=True)
-class GrowattRequiredKeysMixin:
-    """Mixin for required keys."""
-
-    api_key: str
-
-
-@dataclass(frozen=True)
-class GrowattSensorEntityDescription(SensorEntityDescription, GrowattRequiredKeysMixin):
+@dataclass(frozen=True, kw_only=True)
+class GrowattSensorEntityDescription(SensorEntityDescription):
     """Describes Growatt sensor entity."""
 
-    precision: int | None = None
+    api_key: str
     currency: bool = False
     previous_value_drop_threshold: float | None = None
     never_resets: bool = False

homeassistant/components/growatt_server/sensor/sph.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
     PERCENTAGE,
+    EntityCategory,
     UnitOfElectricPotential,
     UnitOfEnergy,
     UnitOfFrequency,
@@ -90,6 +91,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_1",
@@ -98,6 +101,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_2",
@@ -106,6 +111,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_3",
@@ -114,6 +121,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_4",
@@ -122,6 +131,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="sph_temperature_5",
@@ -130,6 +141,8 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     # Values from 'sph_energy' API call
     GrowattSensorEntityDescription(

homeassistant/components/growatt_server/sensor/storage.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
     PERCENTAGE,
+    EntityCategory,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
     UnitOfEnergy,
@@ -189,7 +190,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_pv_charging_voltage",
@@ -198,7 +199,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_pv_charging_voltage_2",
@@ -207,7 +208,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_ac_input_frequency_out",
@@ -216,7 +217,9 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="storage_output_voltage",
@@ -225,7 +228,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_ac_output_frequency",
@@ -234,7 +237,9 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="storage_current_PV",
@@ -243,7 +248,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_current_1",
@@ -252,7 +257,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_current_2",
@@ -261,7 +266,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_grid_amperage_input",
@@ -270,7 +275,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_grid_out_current",
@@ -279,7 +284,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_battery_voltage",
@@ -288,7 +293,7 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
     GrowattSensorEntityDescription(
         key="storage_load_percentage",
@@ -297,6 +302,6 @@ STORAGE_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.BATTERY,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=2,
+        suggested_display_precision=2,
     ),
 )

homeassistant/components/growatt_server/sensor/tlx.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import (
     PERCENTAGE,
+    EntityCategory,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
     UnitOfEnergy,
@@ -26,7 +27,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total",
@@ -35,7 +36,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -45,7 +46,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -55,7 +56,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_1",
@@ -63,7 +64,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv1",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_1",
@@ -71,7 +72,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv1",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_1",
@@ -80,7 +81,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total_input_2",
@@ -89,7 +90,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -99,7 +100,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_2",
@@ -107,7 +108,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv2",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_2",
@@ -115,7 +116,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv2",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_2",
@@ -124,7 +125,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total_input_3",
@@ -133,7 +134,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -143,7 +144,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_3",
@@ -151,7 +152,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv3",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_3",
@@ -159,7 +160,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv3",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_3",
@@ -168,7 +169,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_energy_total_input_4",
@@ -177,7 +178,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
         never_resets=True,
     ),
     GrowattSensorEntityDescription(
@@ -187,7 +188,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_voltage_input_4",
@@ -195,7 +196,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vpv4",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_amperage_input_4",
@@ -203,7 +204,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="ipv4",
         native_unit_of_measurement=UnitOfElectricCurrent.AMPERE,
         device_class=SensorDeviceClass.CURRENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_wattage_input_4",
@@ -212,7 +213,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_solar_generation_today",
@@ -221,7 +222,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_solar_generation_total",
@@ -239,7 +240,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_reactive_voltage",
@@ -247,7 +248,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="vacrs",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_frequency",
@@ -255,7 +258,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="fac",
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
         device_class=SensorDeviceClass.FREQUENCY,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_current_wattage",
@@ -264,7 +269,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_1",
@@ -272,7 +277,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp1",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_2",
@@ -280,7 +287,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp2",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_3",
@@ -288,7 +297,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp3",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_4",
@@ -296,7 +307,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp4",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_temperature_5",
@@ -304,7 +317,9 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         api_key="temp5",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
-        precision=1,
+        suggested_display_precision=1,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
     GrowattSensorEntityDescription(
         key="tlx_all_batteries_discharge_today",
@@ -456,7 +471,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_pac_to_user_total",
@@ -465,7 +480,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_pac_to_grid_total",
@@ -474,7 +489,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_system_production_today",
@@ -483,7 +498,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_system_production_total",
@@ -493,7 +508,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_self_consumption_today",
@@ -502,7 +517,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_self_consumption_total",
@@ -512,7 +527,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_import_from_grid_today",
@@ -521,7 +536,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_import_from_grid_total",
@@ -531,7 +546,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_batteries_charged_from_grid_today",
@@ -540,7 +555,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_batteries_charged_from_grid_total",
@@ -550,7 +565,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
         never_resets=True,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_p_system",
@@ -559,7 +574,7 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
     GrowattSensorEntityDescription(
         key="tlx_p_self",
@@ -568,6 +583,6 @@ TLX_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        precision=1,
+        suggested_display_precision=1,
     ),
 )

homeassistant/components/growatt_server/switch.py

@@ -18,7 +18,6 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
 from .coordinator import GrowattConfigEntry, GrowattCoordinator
-from .sensor.sensor_entity_description import GrowattRequiredKeysMixin
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,9 +27,10 @@ PARALLEL_UPDATES = (
 
 
 @dataclass(frozen=True, kw_only=True)
-class GrowattSwitchEntityDescription(SwitchEntityDescription, GrowattRequiredKeysMixin):
+class GrowattSwitchEntityDescription(SwitchEntityDescription):
     """Describes Growatt switch entity."""
 
+    api_key: str
     write_key: str | None = None  # Parameter ID for writing (if different from api_key)
 
 
@@ -87,6 +87,7 @@ class GrowattSwitch(CoordinatorEntity[GrowattCoordinator], SwitchEntity):
             identifiers={(DOMAIN, coordinator.device_id)},
             manufacturer="Growatt",
             name=coordinator.device_id,
+            serial_number=coordinator.device_id,
         )
 
     @property

homeassistant/components/hassio/const.py

@@ -132,6 +132,7 @@ ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED = "issue_addon_detached_addon_removed"
 ISSUE_KEY_ADDON_PWNED = "issue_addon_pwned"
 ISSUE_KEY_SYSTEM_FREE_SPACE = "issue_system_free_space"
 ISSUE_KEY_ADDON_DEPRECATED = "issue_addon_deprecated_addon"
+ISSUE_KEY_ADDON_DEPRECATED_ARCH = "issue_addon_deprecated_arch_addon"
 
 ISSUE_MOUNT_MOUNT_FAILED = "issue_mount_mount_failed"
 
@@ -172,6 +173,7 @@ EXTRA_PLACEHOLDERS = {
         "more_info_pwned": "https://www.home-assistant.io/more-info/pwned-passwords",
     },
     ISSUE_KEY_ADDON_DEPRECATED: HELP_URLS,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH: HELP_URLS,
 }
 
 

homeassistant/components/hassio/issues.py

@@ -47,6 +47,7 @@ from .const import (
     EVENT_SUPPORTED_CHANGED,
     EXTRA_PLACEHOLDERS,
     ISSUE_KEY_ADDON_BOOT_FAIL,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
     ISSUE_KEY_ADDON_DETACHED_ADDON_MISSING,
     ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
     ISSUE_KEY_ADDON_PWNED,
@@ -90,6 +91,8 @@ ISSUE_KEYS_FOR_REPAIRS = {
     "issue_system_disk_lifetime",
     ISSUE_KEY_SYSTEM_FREE_SPACE,
     ISSUE_KEY_ADDON_PWNED,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
+    "issue_system_ntp_sync_failed",
 }
 
 _LOGGER = logging.getLogger(__name__)
@@ -253,9 +256,10 @@ class SupervisorIssues:
     def add_issue(self, issue: Issue) -> None:
         """Add or update an issue in the list. Create or update a repair if necessary."""
         if issue.key in ISSUE_KEYS_FOR_REPAIRS:
-            placeholders: dict[str, str] = {}
             if not issue.suggestions and issue.key in EXTRA_PLACEHOLDERS:
-                placeholders |= EXTRA_PLACEHOLDERS[issue.key]
+                placeholders: dict[str, str] = EXTRA_PLACEHOLDERS[issue.key].copy()
+            else:
+                placeholders = {}
 
             if issue.reference:
                 placeholders[PLACEHOLDER_KEY_REFERENCE] = issue.reference

homeassistant/components/hassio/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/hassio",
   "iot_class": "local_polling",
   "quality_scale": "internal",
-  "requirements": ["aiohasupervisor==0.4.1"],
+  "requirements": ["aiohasupervisor==0.4.2"],
   "single_config_entry": true
 }

homeassistant/components/hassio/repairs.py

@@ -21,6 +21,7 @@ from .const import (
     EXTRA_PLACEHOLDERS,
     ISSUE_KEY_ADDON_BOOT_FAIL,
     ISSUE_KEY_ADDON_DEPRECATED,
+    ISSUE_KEY_ADDON_DEPRECATED_ARCH,
     ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
     ISSUE_KEY_ADDON_PWNED,
     ISSUE_KEY_SYSTEM_DOCKER_CONFIG,
@@ -64,11 +65,16 @@ class SupervisorIssueRepairFlow(RepairsFlow):
     @property
     def description_placeholders(self) -> dict[str, str] | None:
         """Get description placeholders for steps."""
-        placeholders = {}
-        if self.issue:
-            placeholders = EXTRA_PLACEHOLDERS.get(self.issue.key, {})
-            if self.issue.reference:
-                placeholders |= {PLACEHOLDER_KEY_REFERENCE: self.issue.reference}
+        if not self.issue:
+            return None
+
+        if self.issue.key in EXTRA_PLACEHOLDERS:
+            placeholders: dict[str, str] = EXTRA_PLACEHOLDERS[self.issue.key].copy()
+        else:
+            placeholders = {}
+
+        if self.issue.reference:
+            placeholders |= {PLACEHOLDER_KEY_REFERENCE: self.issue.reference}
 
         return placeholders or None
 
@@ -232,6 +238,7 @@ async def async_create_fix_flow(
         ISSUE_KEY_ADDON_DETACHED_ADDON_REMOVED,
         ISSUE_KEY_ADDON_BOOT_FAIL,
         ISSUE_KEY_ADDON_PWNED,
+        ISSUE_KEY_ADDON_DEPRECATED_ARCH,
     }:
         return AddonIssueRepairFlow(hass, issue_id)
 

homeassistant/components/hassio/strings.json

@@ -85,6 +85,19 @@
       },
       "title": "Installed app is deprecated"
     },
+    "issue_addon_deprecated_arch_addon": {
+      "fix_flow": {
+        "abort": {
+          "apply_suggestion_fail": "Could not uninstall the app. Check the Supervisor logs for more details."
+        },
+        "step": {
+          "addon_execute_remove": {
+            "description": "App {addon} only supports architectures and/or machines which are no longer supported by Home Assistant. It will stop working in a future release.\n\nSelecting **Submit** will uninstall this deprecated app. Alternatively, you can check [Home Assistant help]({help_url}) and the [community forum]({community_url}) for alternatives to migrate to."
+          }
+        }
+      },
+      "title": "Installed app is built for unsupported architectures and/or machines"
+    },
     "issue_addon_detached_addon_missing": {
       "description": "Repository for app {addon} is missing. This means it will not get updates, and backups may not be restored correctly as the Home Assistant Supervisor may not be able to build/download the resources required.\n\nPlease check the [app's documentation]({addon_url}) for installation instructions and add the repository to the store.",
       "title": "Missing repository for an installed app"
@@ -164,6 +177,19 @@
       },
       "title": "Multiple data disks detected"
     },
+    "issue_system_ntp_sync_failed": {
+      "fix_flow": {
+        "abort": {
+          "apply_suggestion_fail": "Could not re-enable NTP. Check the Supervisor logs for more details."
+        },
+        "step": {
+          "system_enable_ntp": {
+            "description": "The device could not contact its configured time servers (NTP). Using a secondary online time check, we detected that the system clock was more than 1 hour incorrect. The time has been corrected and the NTP service was temporarily disabled so the correction could be applied. To keep the system time accurate, we recommend fixing the issue preventing access to the NTP servers.\n\nCheck the **Host logs** to investigate why NTP servers could not be reached. Once resolved, select **Submit** to re-enable the NTP service."
+          }
+        }
+      },
+      "title": "Time synchronization issue detected"
+    },
     "issue_system_reboot_required": {
       "fix_flow": {
         "abort": {

homeassistant/components/huum/climate.py

@@ -72,13 +72,6 @@ class HuumDevice(HuumBaseEntity, ClimateEntity):
             return HVACMode.HEAT
         return HVACMode.OFF
 
-    @property
-    def icon(self) -> str:
-        """Return nice icon for heater."""
-        if self.hvac_mode == HVACMode.HEAT:
-            return "mdi:radiator"
-        return "mdi:radiator-off"
-
     @property
     def current_temperature(self) -> int | None:
         """Return the current temperature."""

homeassistant/components/huum/config_flow.py

@@ -45,8 +45,6 @@ class HuumConfigFlow(ConfigFlow, domain=DOMAIN):
                 )
                 await huum.status()
             except Forbidden, NotAuthenticated:
-                # Most likely Forbidden as that is what is returned from `.status()` with bad creds
-                _LOGGER.error("Could not log in to Huum with given credentials")
                 errors["base"] = "invalid_auth"
             except Exception:
                 _LOGGER.exception("Unknown error")

homeassistant/components/huum/coordinator.py

@@ -54,7 +54,6 @@ class HuumDataUpdateCoordinator(DataUpdateCoordinator[HuumStatusResponse]):
         try:
             return await self.huum.status()
         except (Forbidden, NotAuthenticated) as err:
-            _LOGGER.error("Could not log in to Huum with given credentials")
             raise UpdateFailed(
                 "Could not log in to Huum with given credentials"
             ) from err

homeassistant/components/huum/quality_scale.yaml

@@ -7,11 +7,7 @@ rules:
   brands: done
   common-modules: done
   config-flow-test-coverage: done
-  config-flow:
-    status: done
-    comment: |
-      PLANNED: Remove _LOGGER.error call from config_flow.py — the error
-      message is redundant with the errors dict entry.
+  config-flow: done
   dependency-transparency: done
   docs-actions:
     status: exempt
@@ -40,11 +36,7 @@ rules:
   docs-installation-parameters: done
   entity-unavailable: done
   integration-owner: done
-  log-when-unavailable:
-    status: done
-    comment: |
-      PLANNED: Remove _LOGGER.error from coordinator.py — the message is already
-      passed to UpdateFailed, so logging it separately is redundant.
+  log-when-unavailable: done
   parallel-updates: done
   reauthentication-flow: todo
   test-coverage:
@@ -74,11 +66,7 @@ rules:
     comment: All entities are core functionality.
   entity-translations: done
   exception-translations: todo
-  icon-translations:
-    status: done
-    comment: |
-      PLANNED: Remove the icon property from climate.py — entities should not set
-      custom icons. Use HA defaults or icon translations instead.
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/intellifire/strings.json

@@ -22,7 +22,13 @@
         "description": "Authenticate against IntelliFire cloud"
       },
       "pick_cloud_device": {
-        "description": "Select fireplace by serial number:",
+        "data": {
+          "serial": "Fireplace serial number"
+        },
+        "data_description": {
+          "serial": "Serial number of the fireplace to configure"
+        },
+        "description": "Select fireplace by serial number.",
         "title": "Configure fireplace"
       }
     }
@@ -159,6 +165,10 @@
           "control_mode": "Send commands to",
           "read_mode": "Read data from"
         },
+        "data_description": {
+          "control_mode": "Whether to send fireplace commands via the `Local` or `Cloud` API",
+          "read_mode": "Whether to read fireplace state via the `Local` or `Cloud` API"
+        },
         "description": "Some users find that their fireplace hardware prioritizes `Cloud` communication and may experience timeouts with `Local` control. If you encounter connectivity issues, try switching to `Cloud` for the affected endpoint.",
         "title": "Endpoint selection"
       }

homeassistant/components/jvc_projector/coordinator.py

@@ -151,7 +151,9 @@ class JvcProjectorDataUpdateCoordinator(DataUpdateCoordinator[dict[str, str]]):
 
         return value
 
-    def get_options_map(self, command: str) -> dict[str, str]:
+    def get_options_map(
+        self, command: str, *, snake_case: bool = False
+    ) -> dict[str, str]:
         """Get the available options for a command."""
         capabilities = self.capabilities.get(command, {})
 
@@ -162,7 +164,10 @@ class JvcProjectorDataUpdateCoordinator(DataUpdateCoordinator[dict[str, str]]):
 
         values = list(capabilities.get("parameter", {}).get("read", {}).values())
 
-        return {v: v.translate(TRANSLATIONS) for v in values}
+        options = {v: v.translate(TRANSLATIONS) for v in values}
+        if snake_case:
+            return {k: v.replace("-", "_") for k, v in options.items()}
+        return options
 
     def supports(self, command: type[Command]) -> bool:
         """Check if the device supports a command."""

homeassistant/components/jvc_projector/icons.json

@@ -18,6 +18,9 @@
       "dynamic_control": {
         "default": "mdi:lightbulb-on-outline"
       },
+      "hdr_processing": {
+        "default": "mdi:image-filter-hdr-outline"
+      },
       "input": {
         "default": "mdi:hdmi-port"
       },
@@ -26,6 +29,9 @@
       },
       "light_power": {
         "default": "mdi:lightbulb-on-outline"
+      },
+      "picture_mode": {
+        "default": "mdi:movie-roll"
       }
     },
     "sensor": {

homeassistant/components/jvc_projector/select.py

@@ -20,6 +20,7 @@ class JvcProjectorSelectDescription(SelectEntityDescription):
     """Describes JVC Projector select entities."""
 
     command: type[Command]
+    snake_case_states: bool = False
 
 
 SELECTS: Final[tuple[JvcProjectorSelectDescription, ...]] = (
@@ -49,6 +50,18 @@ SELECTS: Final[tuple[JvcProjectorSelectDescription, ...]] = (
         command=cmd.Anamorphic,
         entity_registry_enabled_default=False,
     ),
+    JvcProjectorSelectDescription(
+        key="hdr_processing",
+        command=cmd.HdrProcessing,
+        entity_registry_enabled_default=False,
+        snake_case_states=True,
+    ),
+    JvcProjectorSelectDescription(
+        key="picture_mode",
+        command=cmd.PictureMode,
+        entity_registry_enabled_default=False,
+        snake_case_states=True,
+    ),
 )
 
 
@@ -84,7 +97,8 @@ class JvcProjectorSelectEntity(JvcProjectorEntity, SelectEntity):
         self._attr_unique_id = f"{self._attr_unique_id}_{description.key}"
 
         self._options_map: dict[str, str] = coordinator.get_options_map(
-            self.command.name
+            self.command.name,
+            snake_case=description.snake_case_states,
         )
 
     @property

homeassistant/components/jvc_projector/sensor.py

@@ -7,16 +7,19 @@ from dataclasses import dataclass
 from jvcprojector import Command, command as cmd
 
 from homeassistant.components.sensor import (
+    DOMAIN as SENSOR_DOMAIN,
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
 )
 from homeassistant.const import EntityCategory, UnitOfTime
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import JVCConfigEntry, JvcProjectorDataUpdateCoordinator
 from .entity import JvcProjectorEntity
+from .util import deprecate_entity
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -84,12 +87,29 @@ async def async_setup_entry(
 ) -> None:
     """Set up the JVC Projector platform from a config entry."""
     coordinator = entry.runtime_data
+    entity_registry = er.async_get(hass)
 
-    async_add_entities(
-        JvcProjectorSensorEntity(coordinator, description)
-        for description in SENSORS
-        if coordinator.supports(description.command)
-    )
+    entities: list[JvcProjectorSensorEntity] = []
+    for description in SENSORS:
+        if not coordinator.supports(description.command):
+            continue
+        if description.key in (
+            "hdr_processing",
+            "picture_mode",
+        ) and not deprecate_entity(
+            hass,
+            entity_registry,
+            SENSOR_DOMAIN,
+            f"{coordinator.unique_id}_{description.key}",
+            f"deprecated_sensor_{entry.entry_id}_{description.key}",
+            "deprecated_sensor",
+            f"{coordinator.unique_id}_{description.key}",
+            f"select.jvc_projector_{description.key}",
+        ):
+            continue
+        entities.append(JvcProjectorSensorEntity(coordinator, description))
+
+    async_add_entities(entities)
 
 
 class JvcProjectorSensorEntity(JvcProjectorEntity, SensorEntity):

homeassistant/components/jvc_projector/strings.json

@@ -71,6 +71,15 @@
           "off": "[%key:common::state::off%]"
         }
       },
+      "hdr_processing": {
+        "name": "HDR Processing",
+        "state": {
+          "frame_by_frame": "Frame-by-Frame",
+          "hdr10p": "HDR10+",
+          "scene_by_scene": "Scene-by-Scene",
+          "static": "Static"
+        }
+      },
       "input": {
         "name": "Input",
         "state": {
@@ -101,6 +110,23 @@
           "mid": "[%key:common::state::medium%]",
           "normal": "[%key:common::state::normal%]"
         }
+      },
+      "picture_mode": {
+        "name": "Picture Mode",
+        "state": {
+          "frame_adapt_hdr": "Frame Adapt HDR",
+          "frame_adapt_hdr2": "Frame Adapt HDR2",
+          "frame_adapt_hdr3": "Frame Adapt HDR3",
+          "hdr1": "HDR1",
+          "hdr10": "HDR10",
+          "hdr10_ll": "HDR10 LL",
+          "hdr2": "HDR2",
+          "last_setting": "Last setting",
+          "pana_pq": "Pana PQ",
+          "user_4": "User 4",
+          "user_5": "User 5",
+          "user_6": "User 6"
+        }
       }
     },
     "sensor": {
@@ -156,7 +182,7 @@
           "hdr10": "HDR10",
           "hdr10-ll": "HDR10 LL",
           "hdr2": "HDR2",
-          "last-setting": "Last Setting",
+          "last-setting": "Last setting",
           "pana-pq": "Pana PQ",
           "user-4": "User 4",
           "user-5": "User 5",
@@ -182,5 +208,15 @@
         "name": "Low latency mode"
       }
     }
+  },
+  "issues": {
+    "deprecated_sensor": {
+      "description": "The sensor {entity_name} (`{entity_id}`) is deprecated because it has been replaced with `{replacement_entity_id}`.\n\nUpdate your dashboards, templates, automations and scripts to use the replacement entity, then disable the deprecated sensor to have it removed after the next restart.",
+      "title": "Deprecated sensor detected"
+    },
+    "deprecated_sensor_scripts": {
+      "description": "The sensor {entity_name} (`{entity_id}`) is deprecated because it has been replaced with `{replacement_entity_id}`.\n\nThe sensor was used in the following automations or scripts:\n{items}\n\nUpdate the above automations or scripts to use the replacement entity, then disable the deprecated sensor to have it removed after the next restart.",
+      "title": "[%key:component::jvc_projector::issues::deprecated_sensor::title%]"
+    }
   }
 }

homeassistant/components/jvc_projector/util.py

@@ -0,0 +1,104 @@
+"""Utility helpers for the jvc_projector integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.automation import automations_with_entity
+from homeassistant.components.script import scripts_with_entity
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.issue_registry import (
+    IssueSeverity,
+    async_create_issue,
+    async_delete_issue,
+)
+
+from .const import DOMAIN
+
+
+def deprecate_entity(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    platform_domain: str,
+    entity_unique_id: str,
+    issue_id: str,
+    issue_string: str,
+    replacement_entity_unique_id: str,
+    replacement_entity_id: str,
+    version: str = "2026.9.0",
+) -> bool:
+    """Create an issue for deprecated entities."""
+    if entity_id := entity_registry.async_get_entity_id(
+        platform_domain, DOMAIN, entity_unique_id
+    ):
+        entity_entry = entity_registry.async_get(entity_id)
+        if not entity_entry:
+            async_delete_issue(hass, DOMAIN, issue_id)
+            return False
+
+        items = get_automations_and_scripts_using_entity(hass, entity_id)
+        if entity_entry.disabled and not items:
+            entity_registry.async_remove(entity_id)
+            async_delete_issue(hass, DOMAIN, issue_id)
+            return False
+
+        translation_key = issue_string
+        placeholders = {
+            "entity_id": entity_id,
+            "entity_name": entity_entry.name or entity_entry.original_name or "Unknown",
+            "replacement_entity_id": (
+                entity_registry.async_get_entity_id(
+                    Platform.SELECT, DOMAIN, replacement_entity_unique_id
+                )
+                or replacement_entity_id
+            ),
+        }
+        if items:
+            translation_key = f"{translation_key}_scripts"
+            placeholders["items"] = "\n".join(items)
+
+        async_create_issue(
+            hass,
+            DOMAIN,
+            issue_id,
+            breaks_in_ha_version=version,
+            is_fixable=False,
+            severity=IssueSeverity.WARNING,
+            translation_key=translation_key,
+            translation_placeholders=placeholders,
+        )
+        return True
+
+    async_delete_issue(hass, DOMAIN, issue_id)
+    return False
+
+
+def get_automations_and_scripts_using_entity(
+    hass: HomeAssistant,
+    entity_id: str,
+) -> list[str]:
+    """Get automations and scripts using an entity."""
+    # These helpers return referencing automation/script entity IDs.
+    automations = automations_with_entity(hass, entity_id)
+    scripts = scripts_with_entity(hass, entity_id)
+    if not automations and not scripts:
+        return []
+
+    entity_registry = er.async_get(hass)
+    items: list[str] = []
+
+    for integration, entities in (
+        ("automation", automations),
+        ("script", scripts),
+    ):
+        for used_entity_id in entities:
+            # Prefer entity-registry metadata so we can render edit links.
+            if item := entity_registry.async_get(used_entity_id):
+                items.append(
+                    f"- [{item.original_name}](/config/{integration}/edit/{item.unique_id})"
+                )
+            else:
+                # Keep unresolved references as plain text so they still count as usage.
+                items.append(f"- `{used_entity_id}`")
+
+    return items

homeassistant/components/motion/condition.py

@@ -0,0 +1,25 @@
+"""Provides conditions for motion."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
+
+_MOTION_DOMAIN_SPECS = {
+    BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.MOTION)
+}
+
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_detected": make_entity_state_condition(_MOTION_DOMAIN_SPECS, STATE_ON),
+    "is_not_detected": make_entity_state_condition(_MOTION_DOMAIN_SPECS, STATE_OFF),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for motion."""
+    return CONDITIONS

homeassistant/components/motion/conditions.yaml

@@ -0,0 +1,24 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: motion
+
+is_not_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: motion

homeassistant/components/motion/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_detected": {
+      "condition": "mdi:motion-sensor"
+    },
+    "is_not_detected": {
+      "condition": "mdi:motion-sensor-off"
+    }
+  },
   "triggers": {
     "cleared": {
       "trigger": "mdi:motion-sensor-off"

homeassistant/components/motion/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted motion sensors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted motion sensors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_detected": {
+      "description": "Tests if one or more motion sensors are detecting motion.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::motion::common::condition_behavior_description%]",
+          "name": "[%key:component::motion::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Motion is detected"
+    },
+    "is_not_detected": {
+      "description": "Tests if one or more motion sensors are not detecting motion.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::motion::common::condition_behavior_description%]",
+          "name": "[%key:component::motion::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Motion is not detected"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/mqtt/abbreviations.py

@@ -18,6 +18,8 @@ ABBREVIATIONS = {
     "bri_stat_t": "brightness_state_topic",
     "bri_tpl": "brightness_template",
     "bri_val_tpl": "brightness_value_template",
+    "cln_segmnts_cmd_t": "clean_segments_command_topic",
+    "cln_segmnts_cmd_tpl": "clean_segments_command_template",
     "clr_temp_cmd_tpl": "color_temp_command_template",
     "clrm_stat_t": "color_mode_state_topic",
     "clrm_val_tpl": "color_mode_value_template",
@@ -185,6 +187,7 @@ ABBREVIATIONS = {
     "rgbww_cmd_t": "rgbww_command_topic",
     "rgbww_stat_t": "rgbww_state_topic",
     "rgbww_val_tpl": "rgbww_value_template",
+    "segmnts": "segments",
     "send_cmd_t": "send_command_topic",
     "send_if_off": "send_if_off",
     "set_fan_spd_t": "set_fan_speed_topic",

homeassistant/components/mqtt/entity.py

@@ -1484,6 +1484,7 @@ class MqttEntity(
         self._config = config
         self._setup_from_config(self._config)
         self._setup_common_attributes_from_config(self._config)
+        self._process_entity_update()
 
         # Prepare MQTT subscriptions
         self.attributes_prepare_discovery_update(config)
@@ -1586,6 +1587,10 @@ class MqttEntity(
     def _setup_from_config(self, config: ConfigType) -> None:
         """(Re)Setup the entity."""
 
+    @callback
+    def _process_entity_update(self) -> None:
+        """Process an entity discovery update."""
+
     @abstractmethod
     @callback
     def _prepare_subscribe_topics(self) -> None:

homeassistant/components/mqtt/vacuum.py

@@ -10,12 +10,13 @@ import voluptuous as vol
 from homeassistant.components import vacuum
 from homeassistant.components.vacuum import (
     ENTITY_ID_FORMAT,
+    Segment,
     StateVacuumEntity,
     VacuumActivity,
     VacuumEntityFeature,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_SUPPORTED_FEATURES, CONF_NAME
+from homeassistant.const import ATTR_SUPPORTED_FEATURES, CONF_NAME, CONF_UNIQUE_ID
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -27,7 +28,7 @@ from . import subscription
 from .config import MQTT_BASE_SCHEMA
 from .const import CONF_COMMAND_TOPIC, CONF_RETAIN, CONF_STATE_TOPIC
 from .entity import MqttEntity, async_setup_entity_entry_helper
-from .models import ReceiveMessage
+from .models import MqttCommandTemplate, ReceiveMessage
 from .schemas import MQTT_ENTITY_COMMON_SCHEMA
 from .util import valid_publish_topic
 
@@ -52,6 +53,9 @@ POSSIBLE_STATES: dict[str, VacuumActivity] = {
     STATE_CLEANING: VacuumActivity.CLEANING,
 }
 
+CONF_SEGMENTS = "segments"
+CONF_CLEAN_SEGMENTS_COMMAND_TOPIC = "clean_segments_command_topic"
+CONF_CLEAN_SEGMENTS_COMMAND_TEMPLATE = "clean_segments_command_template"
 CONF_SUPPORTED_FEATURES = ATTR_SUPPORTED_FEATURES
 CONF_PAYLOAD_TURN_ON = "payload_turn_on"
 CONF_PAYLOAD_TURN_OFF = "payload_turn_off"
@@ -137,8 +141,39 @@ MQTT_VACUUM_ATTRIBUTES_BLOCKED = frozenset(
 MQTT_VACUUM_DOCS_URL = "https://www.home-assistant.io/integrations/vacuum.mqtt/"
 
 
-PLATFORM_SCHEMA_MODERN = MQTT_BASE_SCHEMA.extend(
+def validate_clean_area_config(config: ConfigType) -> ConfigType:
+    """Check for a valid configuration and check segments."""
+    if (config[CONF_SEGMENTS] and CONF_CLEAN_SEGMENTS_COMMAND_TOPIC not in config) or (
+        not config[CONF_SEGMENTS] and CONF_CLEAN_SEGMENTS_COMMAND_TOPIC in config
+    ):
+        raise vol.Invalid(
+            f"Options `{CONF_SEGMENTS}` and "
+            f"`{CONF_CLEAN_SEGMENTS_COMMAND_TOPIC}` must be defined together"
+        )
+    segments: list[str]
+    if segments := config[CONF_SEGMENTS]:
+        if not config.get(CONF_UNIQUE_ID):
+            raise vol.Invalid(
+                f"Option `{CONF_SEGMENTS}` requires `{CONF_UNIQUE_ID}` to be configured"
+            )
+        unique_segments: set[str] = set()
+        for segment in segments:
+            segment_id, _, _ = segment.partition(".")
+            if not segment_id or segment_id in unique_segments:
+                raise vol.Invalid(
+                    f"The `{CONF_SEGMENTS}` option contains an invalid or non-"
+                    f"unique segment ID '{segment_id}'. Got {segments}"
+                )
+            unique_segments.add(segment_id)
+
+    return config
+
+
+_BASE_SCHEMA = MQTT_BASE_SCHEMA.extend(
     {
+        vol.Optional(CONF_SEGMENTS, default=[]): vol.All(cv.ensure_list, [cv.string]),
+        vol.Optional(CONF_CLEAN_SEGMENTS_COMMAND_TOPIC): valid_publish_topic,
+        vol.Optional(CONF_CLEAN_SEGMENTS_COMMAND_TEMPLATE): cv.template,
         vol.Optional(CONF_FAN_SPEED_LIST, default=[]): vol.All(
             cv.ensure_list, [cv.string]
         ),
@@ -164,7 +199,10 @@ PLATFORM_SCHEMA_MODERN = MQTT_BASE_SCHEMA.extend(
     }
 ).extend(MQTT_ENTITY_COMMON_SCHEMA.schema)
 
-DISCOVERY_SCHEMA = PLATFORM_SCHEMA_MODERN.extend({}, extra=vol.ALLOW_EXTRA)
+PLATFORM_SCHEMA_MODERN = vol.All(_BASE_SCHEMA, validate_clean_area_config)
+DISCOVERY_SCHEMA = vol.All(
+    _BASE_SCHEMA.extend({}, extra=vol.ALLOW_EXTRA), validate_clean_area_config
+)
 
 
 async def async_setup_entry(
@@ -191,9 +229,11 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
     _entity_id_format = ENTITY_ID_FORMAT
     _attributes_extra_blocked = MQTT_VACUUM_ATTRIBUTES_BLOCKED
 
+    _segments: list[Segment]
     _command_topic: str | None
     _set_fan_speed_topic: str | None
     _send_command_topic: str | None
+    _clean_segments_command_topic: str
     _payloads: dict[str, str | None]
 
     def __init__(
@@ -229,6 +269,23 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
         self._attr_supported_features = _strings_to_services(
             supported_feature_strings, STRING_TO_SERVICE
         )
+        if config[CONF_SEGMENTS] and CONF_CLEAN_SEGMENTS_COMMAND_TOPIC in config:
+            self._attr_supported_features |= VacuumEntityFeature.CLEAN_AREA
+            segments: list[str] = config[CONF_SEGMENTS]
+            self._segments = [
+                Segment(id=segment_id, name=name or segment_id)
+                for segment_id, _, name in [
+                    segment.partition(".") for segment in segments
+                ]
+            ]
+            self._clean_segments_command_topic = config[
+                CONF_CLEAN_SEGMENTS_COMMAND_TOPIC
+            ]
+            self._clean_segments_command_template = MqttCommandTemplate(
+                config.get(CONF_CLEAN_SEGMENTS_COMMAND_TEMPLATE),
+                entity=self,
+            ).async_render
+
         self._attr_fan_speed_list = config[CONF_FAN_SPEED_LIST]
         self._command_topic = config.get(CONF_COMMAND_TOPIC)
         self._set_fan_speed_topic = config.get(CONF_SET_FAN_SPEED_TOPIC)
@@ -246,6 +303,20 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
             )
         }
 
+    @callback
+    def _process_entity_update(self) -> None:
+        """Check vacuum segments with registry entry."""
+        if (
+            self._attr_supported_features & VacuumEntityFeature.CLEAN_AREA
+            and (last_seen := self.last_seen_segments) is not None
+            and {s.id: s for s in last_seen} != {s.id: s for s in self._segments}
+        ):
+            self.async_create_segments_issue()
+
+    async def mqtt_async_added_to_hass(self) -> None:
+        """Check vacuum segments with registry entry."""
+        self._process_entity_update()
+
     def _update_state_attributes(self, payload: dict[str, Any]) -> None:
         """Update the entity state attributes."""
         self._state_attrs.update(payload)
@@ -277,6 +348,19 @@ class MqttStateVacuum(MqttEntity, StateVacuumEntity):
         """(Re)Subscribe to topics."""
         subscription.async_subscribe_topics_internal(self.hass, self._sub_state)
 
+    async def async_clean_segments(self, segment_ids: list[str], **kwargs: Any) -> None:
+        """Perform an area clean."""
+        await self.async_publish_with_config(
+            self._clean_segments_command_topic,
+            self._clean_segments_command_template(
+                json_dumps(segment_ids), {"value": segment_ids}
+            ),
+        )
+
+    async def async_get_segments(self) -> list[Segment]:
+        """Return the available segments."""
+        return self._segments
+
     async def _async_publish_command(self, feature: VacuumEntityFeature) -> None:
         """Publish a command."""
         if self._command_topic is None:

homeassistant/components/occupancy/condition.py

@@ -0,0 +1,25 @@
+"""Provides conditions for occupancy."""
+
+from homeassistant.components.binary_sensor import (
+    DOMAIN as BINARY_SENSOR_DOMAIN,
+    BinarySensorDeviceClass,
+)
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.automation import DomainSpec
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
+
+_OCCUPANCY_DOMAIN_SPECS = {
+    BINARY_SENSOR_DOMAIN: DomainSpec(device_class=BinarySensorDeviceClass.OCCUPANCY)
+}
+
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_detected": make_entity_state_condition(_OCCUPANCY_DOMAIN_SPECS, STATE_ON),
+    "is_not_detected": make_entity_state_condition(_OCCUPANCY_DOMAIN_SPECS, STATE_OFF),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the conditions for occupancy."""
+    return CONDITIONS

homeassistant/components/occupancy/conditions.yaml

@@ -0,0 +1,24 @@
+.condition_common_fields: &condition_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: condition_behavior
+        options:
+          - all
+          - any
+
+is_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: occupancy
+
+is_not_detected:
+  fields: *condition_common_fields
+  target:
+    entity:
+      - domain: binary_sensor
+        device_class: occupancy

homeassistant/components/occupancy/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_detected": {
+      "condition": "mdi:home-account"
+    },
+    "is_not_detected": {
+      "condition": "mdi:home-outline"
+    }
+  },
   "triggers": {
     "cleared": {
       "trigger": "mdi:home-outline"

homeassistant/components/occupancy/strings.json

@@ -1,9 +1,39 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted occupancy sensors.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted occupancy sensors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_detected": {
+      "description": "Tests if one or more occupancy sensors are detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::occupancy::common::condition_behavior_description%]",
+          "name": "[%key:component::occupancy::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Occupancy is detected"
+    },
+    "is_not_detected": {
+      "description": "Tests if one or more occupancy sensors are not detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::occupancy::common::condition_behavior_description%]",
+          "name": "[%key:component::occupancy::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Occupancy is not detected"
+    }
+  },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/opower/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
-  "quality_scale": "silver",
+  "quality_scale": "platinum",
   "requirements": ["opower==0.17.0"]
 }

homeassistant/components/opower/quality_scale.yaml

@@ -58,7 +58,7 @@ rules:
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: todo
+  dynamic-devices: done
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done
@@ -71,7 +71,7 @@ rules:
     status: exempt
     comment: The integration has no user-configurable options that are not authentication-related.
   repair-issues: done
-  stale-devices: todo
+  stale-devices: done
 
   # Platinum
   async-dependency: done

homeassistant/components/opower/sensor.py

@@ -15,7 +15,8 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import EntityCategory, UnitOfEnergy, UnitOfVolume
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -207,48 +208,102 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Opower sensor."""
-
     coordinator = entry.runtime_data
-    entities: list[OpowerSensor] = []
-    opower_data_list = coordinator.data.values()
-    for opower_data in opower_data_list:
-        account = opower_data.account
-        forecast = opower_data.forecast
-        device_id = (
-            f"{coordinator.api.utility.subdomain()}_{account.utility_account_id}"
-        )
-        device = DeviceInfo(
-            identifiers={(DOMAIN, device_id)},
-            name=f"{account.meter_type.name} account {account.utility_account_id}",
-            manufacturer="Opower",
-            model=coordinator.api.utility.name(),
-            entry_type=DeviceEntryType.SERVICE,
-        )
-        sensors: tuple[OpowerEntityDescription, ...] = COMMON_SENSORS
-        if (
-            account.meter_type == MeterType.ELEC
-            and forecast is not None
-            and forecast.unit_of_measure == UnitOfMeasure.KWH
-        ):
-            sensors += ELEC_SENSORS
-        elif (
-            account.meter_type == MeterType.GAS
-            and forecast is not None
-            and forecast.unit_of_measure in [UnitOfMeasure.THERM, UnitOfMeasure.CCF]
-        ):
-            sensors += GAS_SENSORS
-        entities.extend(
-            OpowerSensor(
-                coordinator,
-                sensor,
-                account.utility_account_id,
-                device,
-                device_id,
-            )
-            for sensor in sensors
-        )
+    created_sensors: set[tuple[str, str]] = set()
 
-    async_add_entities(entities)
+    @callback
+    def _update_entities() -> None:
+        """Update entities."""
+        new_entities: list[OpowerSensor] = []
+        current_account_device_ids: set[str] = set()
+        current_account_ids: set[str] = set()
+
+        for opower_data in coordinator.data.values():
+            account = opower_data.account
+            forecast = opower_data.forecast
+            device_id = (
+                f"{coordinator.api.utility.subdomain()}_{account.utility_account_id}"
+            )
+            current_account_device_ids.add(device_id)
+            current_account_ids.add(account.utility_account_id)
+            device = DeviceInfo(
+                identifiers={(DOMAIN, device_id)},
+                name=f"{account.meter_type.name} account {account.utility_account_id}",
+                manufacturer="Opower",
+                model=coordinator.api.utility.name(),
+                entry_type=DeviceEntryType.SERVICE,
+            )
+            sensors: tuple[OpowerEntityDescription, ...] = COMMON_SENSORS
+            if (
+                account.meter_type == MeterType.ELEC
+                and forecast is not None
+                and forecast.unit_of_measure == UnitOfMeasure.KWH
+            ):
+                sensors += ELEC_SENSORS
+            elif (
+                account.meter_type == MeterType.GAS
+                and forecast is not None
+                and forecast.unit_of_measure in [UnitOfMeasure.THERM, UnitOfMeasure.CCF]
+            ):
+                sensors += GAS_SENSORS
+            for sensor in sensors:
+                sensor_key = (account.utility_account_id, sensor.key)
+                if sensor_key in created_sensors:
+                    continue
+                created_sensors.add(sensor_key)
+                new_entities.append(
+                    OpowerSensor(
+                        coordinator,
+                        sensor,
+                        account.utility_account_id,
+                        device,
+                        device_id,
+                    )
+                )
+
+        if new_entities:
+            async_add_entities(new_entities)
+
+        # Remove any registered devices not in the current coordinator data
+        device_registry = dr.async_get(hass)
+        entity_registry = er.async_get(hass)
+        for device_entry in dr.async_entries_for_config_entry(
+            device_registry, entry.entry_id
+        ):
+            device_domain_ids = {
+                identifier[1]
+                for identifier in device_entry.identifiers
+                if identifier[0] == DOMAIN
+            }
+            if not device_domain_ids:
+                # This device has no Opower identifiers; it may be a merged/shared
+                # device owned by another integration. Do not alter it here.
+                continue
+            if not device_domain_ids.isdisjoint(current_account_device_ids):
+                continue  # device is still active
+            # Device is stale — remove its entities then detach it
+            for entity_entry in er.async_entries_for_device(
+                entity_registry, device_entry.id, include_disabled_entities=True
+            ):
+                if entity_entry.config_entry_id != entry.entry_id:
+                    continue
+                entity_registry.async_remove(entity_entry.entity_id)
+            device_registry.async_update_device(
+                device_entry.id, remove_config_entry_id=entry.entry_id
+            )
+
+        # Prune sensor tracking for accounts that are no longer present
+        if created_sensors:
+            stale_sensor_keys = {
+                sensor_key
+                for sensor_key in created_sensors
+                if sensor_key[0] not in current_account_ids
+            }
+            if stale_sensor_keys:
+                created_sensors.difference_update(stale_sensor_keys)
+
+    _update_entities()
+    entry.async_on_unload(coordinator.async_add_listener(_update_entities))
 
 
 class OpowerSensor(CoordinatorEntity[OpowerCoordinator], SensorEntity):
@@ -272,6 +327,11 @@ class OpowerSensor(CoordinatorEntity[OpowerCoordinator], SensorEntity):
         self._attr_device_info = device
         self.utility_account_id = utility_account_id
 
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self.utility_account_id in self.coordinator.data
+
     @property
     def native_value(self) -> StateType | date | datetime:
         """Return the state."""

homeassistant/components/proxmoxve/button.py

@@ -104,7 +104,7 @@ VM_BUTTONS: tuple[ProxmoxVMButtonEntityDescription, ...] = (
     ProxmoxVMButtonEntityDescription(
         key="restart",
         press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).qemu(vmid).status.restart.post()
+            coordinator.proxmox.nodes(node).qemu(vmid).status.reboot.post()
         ),
         entity_category=EntityCategory.CONFIG,
         device_class=ButtonDeviceClass.RESTART,
@@ -147,7 +147,7 @@ CONTAINER_BUTTONS: tuple[ProxmoxContainerButtonEntityDescription, ...] = (
     ProxmoxContainerButtonEntityDescription(
         key="restart",
         press_action=lambda coordinator, node, vmid: (
-            coordinator.proxmox.nodes(node).lxc(vmid).status.restart.post()
+            coordinator.proxmox.nodes(node).lxc(vmid).status.reboot.post()
         ),
         entity_category=EntityCategory.CONFIG,
         device_class=ButtonDeviceClass.RESTART,

homeassistant/components/renault/const.py

@@ -18,6 +18,7 @@ PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
     Platform.DEVICE_TRACKER,
+    Platform.NUMBER,
     Platform.SELECT,
     Platform.SENSOR,
 ]

homeassistant/components/renault/number.py

@@ -0,0 +1,144 @@
+"""Support for Renault number entities."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any, cast
+
+from renault_api.kamereon.models import KamereonVehicleBatterySocData
+
+from homeassistant.components.number import (
+    NumberDeviceClass,
+    NumberEntity,
+    NumberEntityDescription,
+    NumberMode,
+)
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import RenaultConfigEntry
+from .const import DOMAIN
+from .entity import RenaultDataEntity, RenaultDataEntityDescription
+
+# Coordinator is used to centralize the data updates
+# but renault servers are unreliable and it's safer to queue action calls
+PARALLEL_UPDATES = 1
+
+
+@dataclass(frozen=True, kw_only=True)
+class RenaultNumberEntityDescription(
+    NumberEntityDescription, RenaultDataEntityDescription
+):
+    """Class describing Renault number entities."""
+
+    data_key: str
+    update_fn: Callable[[RenaultNumberEntity, float], Coroutine[Any, Any, None]]
+
+
+async def _set_charge_limit_min(entity: RenaultNumberEntity, value: float) -> None:
+    """Set the minimum SOC.
+
+    The target SOC is required to set the minimum SOC, so we need to fetch it first.
+    """
+    if (data := entity.coordinator.data) is None or (
+        target_soc := data.socTarget
+    ) is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="battery_soc_unavailable",
+        )
+    await _set_charge_limits(entity, min_soc=round(value), target_soc=target_soc)
+
+
+async def _set_charge_limit_target(entity: RenaultNumberEntity, value: float) -> None:
+    """Set the target SOC.
+
+    The minimum SOC is required to set the target SOC, so we need to fetch it first.
+    """
+    if (data := entity.coordinator.data) is None or (min_soc := data.socMin) is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="battery_soc_unavailable",
+        )
+    await _set_charge_limits(entity, min_soc=min_soc, target_soc=round(value))
+
+
+async def _set_charge_limits(
+    entity: RenaultNumberEntity, min_soc: int, target_soc: int
+) -> None:
+    """Set the minimum and target SOC.
+
+    Optimistically update local coordinator data so the new
+    limits are reflected immediately without a remote refresh,
+    as Renault servers may still cache old values.
+    """
+    await entity.vehicle.set_battery_soc(min_soc=min_soc, target_soc=target_soc)
+
+    entity.coordinator.data.socMin = min_soc
+    entity.coordinator.data.socTarget = target_soc
+    entity.coordinator.async_set_updated_data(entity.coordinator.data)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: RenaultConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Renault entities from config entry."""
+    entities: list[RenaultNumberEntity] = [
+        RenaultNumberEntity(vehicle, description)
+        for vehicle in config_entry.runtime_data.vehicles.values()
+        for description in NUMBER_TYPES
+        if description.coordinator in vehicle.coordinators
+    ]
+    async_add_entities(entities)
+
+
+class RenaultNumberEntity(
+    RenaultDataEntity[KamereonVehicleBatterySocData], NumberEntity
+):
+    """Mixin for number specific attributes."""
+
+    entity_description: RenaultNumberEntityDescription
+
+    @property
+    def native_value(self) -> float | None:
+        """Return the entity value to represent the entity state."""
+        return cast(float | None, self._get_data_attr(self.entity_description.data_key))
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Update the current value."""
+        await self.entity_description.update_fn(self, value)
+
+
+NUMBER_TYPES: tuple[RenaultNumberEntityDescription, ...] = (
+    RenaultNumberEntityDescription(
+        key="charge_limit_min",
+        coordinator="battery_soc",
+        data_key="socMin",
+        update_fn=_set_charge_limit_min,
+        device_class=NumberDeviceClass.BATTERY,
+        native_min_value=15,
+        native_max_value=45,
+        native_step=5,
+        native_unit_of_measurement=PERCENTAGE,
+        mode=NumberMode.SLIDER,
+        translation_key="charge_limit_min",
+    ),
+    RenaultNumberEntityDescription(
+        key="charge_limit_target",
+        coordinator="battery_soc",
+        data_key="socTarget",
+        update_fn=_set_charge_limit_target,
+        device_class=NumberDeviceClass.BATTERY,
+        native_min_value=55,
+        native_max_value=100,
+        native_step=5,
+        native_unit_of_measurement=PERCENTAGE,
+        mode=NumberMode.SLIDER,
+        translation_key="charge_limit_target",
+    ),
+)

homeassistant/components/renault/renault_vehicle.py

@@ -174,6 +174,13 @@ class RenaultVehicleProxy:
         """Stop vehicle charge."""
         return await self._vehicle.set_charge_stop()
 
+    @with_error_wrapping
+    async def set_battery_soc(
+        self, min_soc: int, target_soc: int
+    ) -> models.KamereonVehicleBatterySocActionData:
+        """Set vehicle battery SoC levels."""
+        return await self._vehicle.set_battery_soc(min=min_soc, target=target_soc)
+
     @with_error_wrapping
     async def set_ac_stop(self) -> models.KamereonVehicleHvacStartActionData:
         """Stop vehicle ac."""
@@ -270,4 +277,10 @@ COORDINATORS: tuple[RenaultCoordinatorDescription, ...] = (
         key="pressure",
         update_method=lambda x: x.get_tyre_pressure,
     ),
+    RenaultCoordinatorDescription(
+        endpoint="soc-levels",
+        key="battery_soc",
+        requires_electricity=True,
+        update_method=lambda x: x.get_battery_soc,
+    ),
 )

homeassistant/components/renault/strings.json

@@ -94,6 +94,14 @@
         "name": "[%key:common::config_flow::data::location%]"
       }
     },
+    "number": {
+      "charge_limit_min": {
+        "name": "Minimum charge level"
+      },
+      "charge_limit_target": {
+        "name": "Target charge level"
+      }
+    },
     "select": {
       "charge_mode": {
         "name": "Charge mode",
@@ -199,6 +207,9 @@
     }
   },
   "exceptions": {
+    "battery_soc_unavailable": {
+      "message": "Battery state of charge data is currently unavailable"
+    },
     "invalid_device_id": {
       "message": "No device with ID {device_id} was found"
     },

homeassistant/components/schedule/condition.py

@@ -0,0 +1,17 @@
+"""Provides conditions for schedules."""
+
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.condition import Condition, make_entity_state_condition
+
+from .const import DOMAIN
+
+CONDITIONS: dict[str, type[Condition]] = {
+    "is_off": make_entity_state_condition(DOMAIN, STATE_OFF),
+    "is_on": make_entity_state_condition(DOMAIN, STATE_ON),
+}
+
+
+async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
+    """Return the schedule conditions."""
+    return CONDITIONS

homeassistant/components/schedule/conditions.yaml

@@ -0,0 +1,17 @@
+.condition_common: &condition_common
+  target:
+    entity:
+      domain: schedule
+  fields:
+    behavior:
+      required: true
+      default: any
+      selector:
+        select:
+          translation_key: condition_behavior
+          options:
+            - all
+            - any
+
+is_off: *condition_common
+is_on: *condition_common

homeassistant/components/schedule/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_off": {
+      "condition": "mdi:calendar-blank"
+    },
+    "is_on": {
+      "condition": "mdi:calendar-clock"
+    }
+  },
   "services": {
     "get_schedule": {
       "service": "mdi:calendar-export"

homeassistant/components/schedule/strings.json

@@ -1,8 +1,32 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted schedules.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted schedules to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_off": {
+      "description": "Tests if one or more schedule blocks are currently not active.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::schedule::common::condition_behavior_description%]",
+          "name": "[%key:component::schedule::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Schedule is off"
+    },
+    "is_on": {
+      "description": "Tests if one or more schedule blocks are currently active.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::schedule::common::condition_behavior_description%]",
+          "name": "[%key:component::schedule::common::condition_behavior_name%]"
+        }
+      },
+      "name": "Schedule is on"
+    }
+  },
   "entity_component": {
     "_": {
       "name": "[%key:component::schedule::title%]",
@@ -25,6 +49,12 @@
     }
   },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/select/icons.json

@@ -20,5 +20,10 @@
     "select_previous": {
       "service": "mdi:format-list-bulleted"
     }
+  },
+  "triggers": {
+    "selection_changed": {
+      "trigger": "mdi:format-list-bulleted"
+    }
   }
 }