Fix FRITZ!Box Tools "the test opens sockets" issue (#165596)

Co-authored-by: Claw <claw@theeggeadventure.com>

.github/workflows/builder.yml

@@ -182,7 +182,7 @@ jobs:
           fi
 
       - name: Download translations
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: translations
 
@@ -490,7 +490,7 @@ jobs:
           python-version-file: ".python-version"
 
       - name: Download translations
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: translations
 

.github/workflows/ci.yaml

@@ -978,7 +978,7 @@ jobs:
         run: |
           echo "::add-matcher::.github/workflows/matchers/pytest-slow.json"
       - name: Download pytest_buckets
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: pytest_buckets
       - name: Compile English translations
@@ -1387,7 +1387,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           pattern: coverage-*
       - name: Upload coverage to Codecov
@@ -1558,7 +1558,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           pattern: coverage-*
       - name: Upload coverage to Codecov
@@ -1587,7 +1587,7 @@ jobs:
       && needs.info.outputs.skip_coverage != 'true' && !cancelled()
     steps:
       - name: Download all coverage artifacts
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           pattern: test-results-*
       - name: Upload test results to Codecov

.github/workflows/wheels.yml

@@ -121,12 +121,12 @@ jobs:
           persist-credentials: false
 
       - name: Download env_file
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: env_file
 
       - name: Download requirements_diff
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: requirements_diff
 
@@ -172,17 +172,17 @@ jobs:
           persist-credentials: false
 
       - name: Download env_file
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: env_file
 
       - name: Download requirements_diff
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: requirements_diff
 
       - name: Download requirements_all_wheels
-        uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           name: requirements_all_wheels
 

.strict-typing

@@ -137,6 +137,7 @@ homeassistant.components.calendar.*
 homeassistant.components.cambridge_audio.*
 homeassistant.components.camera.*
 homeassistant.components.canary.*
+homeassistant.components.casper_glow.*
 homeassistant.components.cert_expiry.*
 homeassistant.components.clickatell.*
 homeassistant.components.clicksend.*
@@ -173,6 +174,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

@@ -273,6 +273,8 @@ build.json @home-assistant/supervisor
 /tests/components/cambridge_audio/ @noahhusby
 /homeassistant/components/camera/ @home-assistant/core
 /tests/components/camera/ @home-assistant/core
+/homeassistant/components/casper_glow/ @mikeodr
+/tests/components/casper_glow/ @mikeodr
 /homeassistant/components/cast/ @emontnemery
 /tests/components/cast/ @emontnemery
 /homeassistant/components/ccm15/ @ocalvo
@@ -397,6 +399,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
@@ -945,6 +949,8 @@ build.json @home-assistant/supervisor
 /tests/components/lg_thinq/ @LG-ThinQ-Integration
 /homeassistant/components/libre_hardware_monitor/ @Sab44
 /tests/components/libre_hardware_monitor/ @Sab44
+/homeassistant/components/lichess/ @aryanhasgithub
+/tests/components/lichess/ @aryanhasgithub
 /homeassistant/components/lidarr/ @tkdrob
 /tests/components/lidarr/ @tkdrob
 /homeassistant/components/liebherr/ @mettolen
@@ -1561,8 +1567,8 @@ build.json @home-assistant/supervisor
 /tests/components/sma/ @kellerza @rklomp @erwindouna
 /homeassistant/components/smappee/ @bsmappee
 /tests/components/smappee/ @bsmappee
-/homeassistant/components/smarla/ @explicatis @rlint-explicatis
-/tests/components/smarla/ @explicatis @rlint-explicatis
+/homeassistant/components/smarla/ @explicatis @johannes-exp
+/tests/components/smarla/ @explicatis @johannes-exp
 /homeassistant/components/smart_meter_texas/ @grahamwetzler
 /tests/components/smart_meter_texas/ @grahamwetzler
 /homeassistant/components/smartthings/ @joostlek
@@ -1829,8 +1835,8 @@ build.json @home-assistant/supervisor
 /tests/components/vegehub/ @thulrus
 /homeassistant/components/velbus/ @Cereal2nd @brefra
 /tests/components/velbus/ @Cereal2nd @brefra
-/homeassistant/components/velux/ @Julius2342 @DeerMaximum @pawlizio @wollew
-/tests/components/velux/ @Julius2342 @DeerMaximum @pawlizio @wollew
+/homeassistant/components/velux/ @Julius2342 @pawlizio @wollew
+/tests/components/velux/ @Julius2342 @pawlizio @wollew
 /homeassistant/components/venstar/ @garbled1 @jhollowe
 /tests/components/venstar/ @garbled1 @jhollowe
 /homeassistant/components/versasense/ @imstevenxyz
@@ -1913,6 +1919,8 @@ build.json @home-assistant/supervisor
 /tests/components/whois/ @frenck
 /homeassistant/components/wiffi/ @mampfes
 /tests/components/wiffi/ @mampfes
+/homeassistant/components/wiim/ @Linkplay2020
+/tests/components/wiim/ @Linkplay2020
 /homeassistant/components/wilight/ @leofig-rj
 /tests/components/wilight/ @leofig-rj
 /homeassistant/components/window/ @home-assistant/core

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/airq/diagnostics.py

@@ -0,0 +1,36 @@
+"""Diagnostics support for air-Q."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_IP_ADDRESS, CONF_PASSWORD, CONF_UNIQUE_ID
+from homeassistant.core import HomeAssistant
+
+from . import AirQConfigEntry
+
+REDACT_CONFIG = {CONF_PASSWORD, CONF_UNIQUE_ID, CONF_IP_ADDRESS, "title"}
+REDACT_DEVICE_INFO = {"identifiers", "name"}
+REDACT_COORDINATOR_DATA = {"DeviceID"}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: AirQConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator = entry.runtime_data
+
+    return {
+        "config_entry": async_redact_data(entry.as_dict(), REDACT_CONFIG),
+        "device_info": async_redact_data(
+            dict(coordinator.device_info), REDACT_DEVICE_INFO
+        ),
+        "coordinator_data": async_redact_data(
+            coordinator.data, REDACT_COORDINATOR_DATA
+        ),
+        "options": {
+            "clip_negative": coordinator.clip_negative,
+            "return_average": coordinator.return_average,
+        },
+    }

homeassistant/components/androidtv_remote/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["androidtvremote2"],
   "quality_scale": "platinum",
-  "requirements": ["androidtvremote2==0.2.3"],
+  "requirements": ["androidtvremote2==0.3.1"],
   "zeroconf": ["_androidtvremote2._tcp.local."]
 }

homeassistant/components/automation/__init__.py

@@ -135,6 +135,7 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "motion",
     "occupancy",
     "person",
+    "schedule",
     "siren",
     "switch",
     "vacuum",

homeassistant/components/axis/hub/api.py

@@ -15,7 +15,7 @@ from homeassistant.const import (
     CONF_USERNAME,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from ..const import LOGGER
 from ..errors import AuthenticationRequired, CannotConnect
@@ -26,7 +26,7 @@ async def get_axis_api(
     config: Mapping[str, Any],
 ) -> axis.AxisDevice:
     """Create a Axis device API."""
-    session = get_async_client(hass, verify_ssl=False)
+    session = async_get_clientsession(hass, verify_ssl=False)
 
     api = axis.AxisDevice(
         Configuration(

homeassistant/components/bsblan/__init__.py

@@ -32,7 +32,7 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_PASSKEY, DOMAIN
+from .const import CONF_PASSKEY, DOMAIN, LOGGER
 from .coordinator import BSBLanFastCoordinator, BSBLanSlowCoordinator
 from .services import async_setup_services
 
@@ -52,7 +52,7 @@ class BSBLanData:
     client: BSBLAN
     device: Device
     info: Info
-    static: StaticState
+    static: StaticState | None
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
@@ -82,11 +82,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
         # the connection by fetching firmware version
         await bsblan.initialize()
 
-        # Fetch device metadata in parallel for faster startup
-        device, info, static = await asyncio.gather(
+        # Fetch required device metadata in parallel for faster startup
+        device, info = await asyncio.gather(
             bsblan.device(),
             bsblan.info(),
-            bsblan.static_values(),
         )
     except BSBLANConnectionError as err:
         raise ConfigEntryNotReady(
@@ -111,6 +110,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
             translation_key="setup_general_error",
         ) from err
 
+    try:
+        static = await bsblan.static_values()
+    except (BSBLANError, TimeoutError) as err:
+        LOGGER.debug(
+            "Static values not available for %s: %s",
+            entry.data[CONF_HOST],
+            err,
+        )
+        static = None
+
     # Create coordinators with the already-initialized client
     fast_coordinator = BSBLanFastCoordinator(hass, entry, bsblan)
     slow_coordinator = BSBLanSlowCoordinator(hass, entry, bsblan)

homeassistant/components/bsblan/climate.py

@@ -90,10 +90,11 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
         self._attr_unique_id = f"{format_mac(data.device.MAC)}-climate"
 
         # Set temperature range if available, otherwise use Home Assistant defaults
-        if data.static.min_temp is not None and data.static.min_temp.value is not None:
-            self._attr_min_temp = data.static.min_temp.value
-        if data.static.max_temp is not None and data.static.max_temp.value is not None:
-            self._attr_max_temp = data.static.max_temp.value
+        if (static := data.static) is not None:
+            if (min_temp := static.min_temp) is not None and min_temp.value is not None:
+                self._attr_min_temp = min_temp.value
+            if (max_temp := static.max_temp) is not None and max_temp.value is not None:
+                self._attr_max_temp = max_temp.value
         self._attr_temperature_unit = data.fast_coordinator.client.get_temperature_unit
 
     @property

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/diagnostics.py

@@ -24,7 +24,7 @@ async def async_get_config_entry_diagnostics(
             "sensor": data.fast_coordinator.data.sensor.model_dump(),
             "dhw": data.fast_coordinator.data.dhw.model_dump(),
         },
-        "static": data.static.model_dump(),
+        "static": data.static.model_dump() if data.static is not None else None,
     }
 
     # Add DHW config and schedule from slow coordinator if available

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

@@ -0,0 +1,39 @@
+"""The Casper Glow integration."""
+
+from __future__ import annotations
+
+from pycasperglow import CasperGlow
+
+from homeassistant.components import bluetooth
+from homeassistant.const import CONF_ADDRESS, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+
+from .coordinator import CasperGlowConfigEntry, CasperGlowCoordinator
+
+PLATFORMS: list[Platform] = [Platform.LIGHT]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: CasperGlowConfigEntry) -> bool:
+    """Set up Casper Glow from a config entry."""
+    address: str = entry.data[CONF_ADDRESS]
+    ble_device = bluetooth.async_ble_device_from_address(hass, address.upper(), True)
+    if not ble_device:
+        raise ConfigEntryNotReady(
+            f"Could not find Casper Glow device with address {address}"
+        )
+
+    glow = CasperGlow(ble_device)
+    coordinator = CasperGlowCoordinator(hass, glow, entry.title)
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    entry.async_on_unload(coordinator.async_start())
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: CasperGlowConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/casper_glow/config_flow.py

@@ -0,0 +1,151 @@
+"""Config flow for Casper Glow integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from bluetooth_data_tools import human_readable_name
+from pycasperglow import CasperGlow, CasperGlowError
+import voluptuous as vol
+
+from homeassistant.components.bluetooth import (
+    BluetoothServiceInfoBleak,
+    async_discovered_service_info,
+)
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ADDRESS
+from homeassistant.helpers.device_registry import format_mac
+
+from .const import DOMAIN, LOCAL_NAMES
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class CasperGlowConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Casper Glow."""
+
+    VERSION = 1
+    MINOR_VERSION = 1
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._discovery_info: BluetoothServiceInfoBleak | None = None
+        self._discovered_devices: dict[str, BluetoothServiceInfoBleak] = {}
+
+    async def async_step_bluetooth(
+        self, discovery_info: BluetoothServiceInfoBleak
+    ) -> ConfigFlowResult:
+        """Handle the bluetooth discovery step."""
+        await self.async_set_unique_id(format_mac(discovery_info.address))
+        self._abort_if_unique_id_configured()
+        self._discovery_info = discovery_info
+        self.context["title_placeholders"] = {
+            "name": human_readable_name(
+                None, discovery_info.name, discovery_info.address
+            )
+        }
+        return await self.async_step_bluetooth_confirm()
+
+    async def async_step_bluetooth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm a discovered Casper Glow device."""
+        assert self._discovery_info is not None
+        if user_input is not None:
+            return self.async_create_entry(
+                title=self.context["title_placeholders"]["name"],
+                data={CONF_ADDRESS: self._discovery_info.address},
+            )
+        glow = CasperGlow(self._discovery_info.device)
+        try:
+            await glow.handshake()
+        except CasperGlowError:
+            return self.async_abort(reason="cannot_connect")
+        except Exception:
+            _LOGGER.exception(
+                "Unexpected error during Casper Glow config flow "
+                "(step=bluetooth_confirm, address=%s)",
+                self._discovery_info.address,
+            )
+            return self.async_abort(reason="unknown")
+        self._set_confirm_only()
+        return self.async_show_form(
+            step_id="bluetooth_confirm",
+            description_placeholders=self.context["title_placeholders"],
+        )
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the user step to pick discovered device."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            address = user_input[CONF_ADDRESS]
+            discovery_info = self._discovered_devices[address]
+            await self.async_set_unique_id(
+                format_mac(discovery_info.address), raise_on_progress=False
+            )
+            self._abort_if_unique_id_configured()
+            glow = CasperGlow(discovery_info.device)
+            try:
+                await glow.handshake()
+            except CasperGlowError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception(
+                    "Unexpected error during Casper Glow config flow "
+                    "(step=user, address=%s)",
+                    discovery_info.address,
+                )
+                errors["base"] = "unknown"
+            else:
+                return self.async_create_entry(
+                    title=human_readable_name(
+                        None, discovery_info.name, discovery_info.address
+                    ),
+                    data={
+                        CONF_ADDRESS: discovery_info.address,
+                    },
+                )
+
+        if discovery := self._discovery_info:
+            self._discovered_devices[discovery.address] = discovery
+        else:
+            current_addresses = self._async_current_ids(include_ignore=False)
+            for discovery in async_discovered_service_info(self.hass):
+                if (
+                    format_mac(discovery.address) in current_addresses
+                    or discovery.address in self._discovered_devices
+                    or not (
+                        discovery.name
+                        and any(
+                            discovery.name.startswith(local_name)
+                            for local_name in LOCAL_NAMES
+                        )
+                    )
+                ):
+                    continue
+                self._discovered_devices[discovery.address] = discovery
+
+        if not self._discovered_devices:
+            return self.async_abort(reason="no_devices_found")
+
+        data_schema = vol.Schema(
+            {
+                vol.Required(CONF_ADDRESS): vol.In(
+                    {
+                        service_info.address: human_readable_name(
+                            None, service_info.name, service_info.address
+                        )
+                        for service_info in self._discovered_devices.values()
+                    }
+                ),
+            }
+        )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=data_schema,
+            errors=errors,
+        )

homeassistant/components/casper_glow/const.py

@@ -0,0 +1,16 @@
+"""Constants for the Casper Glow integration."""
+
+from datetime import timedelta
+
+from pycasperglow import BRIGHTNESS_LEVELS, DEVICE_NAME_PREFIX, DIMMING_TIME_MINUTES
+
+DOMAIN = "casper_glow"
+
+LOCAL_NAMES = {DEVICE_NAME_PREFIX}
+
+SORTED_BRIGHTNESS_LEVELS = sorted(BRIGHTNESS_LEVELS)
+
+DEFAULT_DIMMING_TIME_MINUTES: int = DIMMING_TIME_MINUTES[0]
+
+# Interval between periodic state polls to catch externally-triggered changes.
+STATE_POLL_INTERVAL = timedelta(seconds=30)

homeassistant/components/casper_glow/coordinator.py

@@ -0,0 +1,103 @@
+"""Coordinator for the Casper Glow integration."""
+
+from __future__ import annotations
+
+import logging
+
+from bleak import BleakError
+from bluetooth_data_tools import monotonic_time_coarse
+from pycasperglow import CasperGlow
+
+from homeassistant.components.bluetooth import (
+    BluetoothChange,
+    BluetoothScanningMode,
+    BluetoothServiceInfoBleak,
+)
+from homeassistant.components.bluetooth.active_update_coordinator import (
+    ActiveBluetoothDataUpdateCoordinator,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+
+from .const import STATE_POLL_INTERVAL
+
+_LOGGER = logging.getLogger(__name__)
+
+type CasperGlowConfigEntry = ConfigEntry[CasperGlowCoordinator]
+
+
+class CasperGlowCoordinator(ActiveBluetoothDataUpdateCoordinator[None]):
+    """Coordinator for Casper Glow BLE devices."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        device: CasperGlow,
+        title: str,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass=hass,
+            logger=_LOGGER,
+            address=device.address,
+            mode=BluetoothScanningMode.PASSIVE,
+            needs_poll_method=self._needs_poll,
+            poll_method=self._async_update,
+            connectable=True,
+        )
+        self.device = device
+        self.last_dimming_time_minutes: int | None = (
+            device.state.configured_dimming_time_minutes
+        )
+        self.title = title
+
+    @callback
+    def _needs_poll(
+        self,
+        service_info: BluetoothServiceInfoBleak,
+        seconds_since_last_poll: float | None,
+    ) -> bool:
+        """Return True if a poll is needed."""
+        return (
+            seconds_since_last_poll is None
+            or seconds_since_last_poll >= STATE_POLL_INTERVAL.total_seconds()
+        )
+
+    async def _async_update(self, service_info: BluetoothServiceInfoBleak) -> None:
+        """Poll device state."""
+        await self.device.query_state()
+
+    async def _async_poll(self) -> None:
+        """Poll the device and log availability changes."""
+        assert self._last_service_info
+
+        try:
+            await self._async_poll_data(self._last_service_info)
+        except BleakError as exc:
+            if self.last_poll_successful:
+                _LOGGER.info("%s is unavailable: %s", self.title, exc)
+                self.last_poll_successful = False
+            return
+        except Exception:
+            if self.last_poll_successful:
+                _LOGGER.exception("%s: unexpected error while polling", self.title)
+                self.last_poll_successful = False
+            return
+        finally:
+            self._last_poll = monotonic_time_coarse()
+
+        if not self.last_poll_successful:
+            _LOGGER.info("%s is back online", self.title)
+            self.last_poll_successful = True
+
+        self._async_handle_bluetooth_poll()
+
+    @callback
+    def _async_handle_bluetooth_event(
+        self,
+        service_info: BluetoothServiceInfoBleak,
+        change: BluetoothChange,
+    ) -> None:
+        """Update BLE device reference on each advertisement."""
+        self.device.set_ble_device(service_info.device)
+        super()._async_handle_bluetooth_event(service_info, change)

homeassistant/components/casper_glow/entity.py

@@ -0,0 +1,47 @@
+"""Base entity for the Casper Glow integration."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable
+
+from pycasperglow import CasperGlowError
+
+from homeassistant.components.bluetooth.passive_update_coordinator import (
+    PassiveBluetoothCoordinatorEntity,
+)
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceInfo, format_mac
+
+from .const import DOMAIN
+from .coordinator import CasperGlowCoordinator
+
+
+class CasperGlowEntity(PassiveBluetoothCoordinatorEntity[CasperGlowCoordinator]):
+    """Base class for Casper Glow entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: CasperGlowCoordinator) -> None:
+        """Initialize a Casper Glow entity."""
+        super().__init__(coordinator)
+        self._device = coordinator.device
+        self._attr_device_info = DeviceInfo(
+            manufacturer="Casper",
+            model="Glow",
+            model_id="G01",
+            connections={
+                (dr.CONNECTION_BLUETOOTH, format_mac(coordinator.device.address))
+            },
+        )
+
+    async def _async_command(self, coro: Awaitable[None]) -> None:
+        """Execute a device command."""
+        try:
+            await coro
+        except CasperGlowError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="communication_error",
+                translation_placeholders={"error": str(err)},
+            ) from err

homeassistant/components/casper_glow/light.py

@@ -0,0 +1,104 @@
+"""Casper Glow integration light platform."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pycasperglow import GlowState
+
+from homeassistant.components.light import ATTR_BRIGHTNESS, ColorMode, LightEntity
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.device_registry import format_mac
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.util.percentage import (
+    ordered_list_item_to_percentage,
+    percentage_to_ordered_list_item,
+)
+
+from .const import DEFAULT_DIMMING_TIME_MINUTES, SORTED_BRIGHTNESS_LEVELS
+from .coordinator import CasperGlowConfigEntry, CasperGlowCoordinator
+from .entity import CasperGlowEntity
+
+PARALLEL_UPDATES = 1
+
+
+def _ha_brightness_to_device_pct(brightness: int) -> int:
+    """Convert HA brightness (1-255) to device percentage by snapping to nearest."""
+    return percentage_to_ordered_list_item(
+        SORTED_BRIGHTNESS_LEVELS, round(brightness * 100 / 255)
+    )
+
+
+def _device_pct_to_ha_brightness(pct: int) -> int:
+    """Convert device brightness percentage (60-100) to HA brightness (1-255)."""
+    percent = ordered_list_item_to_percentage(SORTED_BRIGHTNESS_LEVELS, pct)
+    return round(percent * 255 / 100)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: CasperGlowConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the light platform for Casper Glow."""
+    async_add_entities([CasperGlowLight(entry.runtime_data)])
+
+
+class CasperGlowLight(CasperGlowEntity, LightEntity):
+    """Representation of a Casper Glow light."""
+
+    _attr_supported_color_modes = {ColorMode.BRIGHTNESS}
+    _attr_name = None
+
+    def __init__(self, coordinator: CasperGlowCoordinator) -> None:
+        """Initialize a Casper Glow light."""
+        super().__init__(coordinator)
+        self._attr_unique_id = format_mac(coordinator.device.address)
+        self._update_from_state(coordinator.device.state)
+
+    async def async_added_to_hass(self) -> None:
+        """Register state update callback when entity is added."""
+        await super().async_added_to_hass()
+        self.async_on_remove(
+            self._device.register_callback(self._async_handle_state_update)
+        )
+
+    @callback
+    def _update_from_state(self, state: GlowState) -> None:
+        """Update entity attributes from device state."""
+        if state.is_on is not None:
+            self._attr_is_on = state.is_on
+            self._attr_color_mode = ColorMode.BRIGHTNESS
+        if state.brightness_level is not None:
+            self._attr_brightness = _device_pct_to_ha_brightness(state.brightness_level)
+
+    @callback
+    def _async_handle_state_update(self, state: GlowState) -> None:
+        """Handle a state update from the device."""
+        self._update_from_state(state)
+        self.async_write_ha_state()
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the light on."""
+        brightness_pct: int | None = None
+        if ATTR_BRIGHTNESS in kwargs:
+            brightness_pct = _ha_brightness_to_device_pct(kwargs[ATTR_BRIGHTNESS])
+
+        await self._async_command(self._device.turn_on())
+        self._attr_is_on = True
+        self._attr_color_mode = ColorMode.BRIGHTNESS
+        if brightness_pct is not None:
+            await self._async_command(
+                self._device.set_brightness_and_dimming_time(
+                    brightness_pct,
+                    self.coordinator.last_dimming_time_minutes
+                    if self.coordinator.last_dimming_time_minutes is not None
+                    else DEFAULT_DIMMING_TIME_MINUTES,
+                )
+            )
+            self._attr_brightness = _device_pct_to_ha_brightness(brightness_pct)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the light off."""
+        await self._async_command(self._device.turn_off())
+        self._attr_is_on = False

homeassistant/components/casper_glow/manifest.json

@@ -0,0 +1,19 @@
+{
+  "domain": "casper_glow",
+  "name": "Casper Glow",
+  "bluetooth": [
+    {
+      "connectable": true,
+      "local_name": "Jar*"
+    }
+  ],
+  "codeowners": ["@mikeodr"],
+  "config_flow": true,
+  "dependencies": ["bluetooth_adapters"],
+  "documentation": "https://www.home-assistant.io/integrations/casper_glow",
+  "integration_type": "device",
+  "iot_class": "local_polling",
+  "loggers": ["pycasperglow"],
+  "quality_scale": "bronze",
+  "requirements": ["pycasperglow==1.1.0"]
+}

homeassistant/components/casper_glow/quality_scale.yaml

@@ -0,0 +1,74 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: No custom services.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: No custom actions/services.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: No network discovery.
+  discovery: done
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations:
+    status: exempt
+    comment: No entity translations needed.
+  exception-translations:
+    status: exempt
+    comment: No custom services that raise exceptions.
+  icon-translations:
+    status: exempt
+    comment: No icon translations needed.
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession:
+    status: exempt
+    comment: No web session is used by this integration.
+  strict-typing: done

homeassistant/components/casper_glow/strings.json

@@ -0,0 +1,34 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "flow_title": "{name}",
+    "step": {
+      "bluetooth_confirm": {
+        "description": "Do you want to set up {name}?"
+      },
+      "user": {
+        "data": {
+          "address": "Bluetooth address"
+        },
+        "data_description": {
+          "address": "The Bluetooth address of the Casper Glow light"
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "communication_error": {
+      "message": "An error occurred while communicating with the Casper Glow: {error}"
+    }
+  }
+}

homeassistant/components/cover/trigger.py

@@ -1,7 +1,7 @@
 """Provides triggers for covers."""
 
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN
-from homeassistant.core import HomeAssistant, State, split_entity_id
+from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers.trigger import EntityTriggerBase, Trigger
 
 from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
@@ -13,14 +13,14 @@ class CoverTriggerBase(EntityTriggerBase[CoverDomainSpec]):
 
     def _get_value(self, state: State) -> str | bool | None:
         """Extract the relevant value from state based on domain spec."""
-        domain_spec = self._domain_specs[split_entity_id(state.entity_id)[0]]
+        domain_spec = self._domain_specs[state.domain]
         if domain_spec.value_source is not None:
             return state.attributes.get(domain_spec.value_source)
         return state.state
 
     def is_valid_state(self, state: State) -> bool:
         """Check if the state matches the target cover state."""
-        domain_spec = self._domain_specs[split_entity_id(state.entity_id)[0]]
+        domain_spec = self._domain_specs[state.domain]
         return self._get_value(state) == domain_spec.target_value
 
     def is_valid_transition(self, from_state: State, to_state: State) -> bool:

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/energy/data.py

@@ -9,7 +9,7 @@ from typing import Any, Literal, NotRequired, TypedDict
 
 import voluptuous as vol
 
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant, callback, valid_entity_id
 from homeassistant.helpers import config_validation as cv, singleton, storage
 
 from .const import DOMAIN
@@ -244,6 +244,38 @@ class EnergyPreferencesUpdate(EnergyPreferences, total=False):
     """all types optional."""
 
 
+def _reject_price_for_external_stat(
+    *,
+    stat_key: str,
+    entity_price_key: str = "entity_energy_price",
+    number_price_key: str = "number_energy_price",
+    cost_stat_key: str = "stat_cost",
+) -> Callable[[dict[str, Any]], dict[str, Any]]:
+    """Return a validator that rejects entity/number price for external statistics.
+
+    Only rejects when the cost/compensation stat is not already set, since
+    price fields are ignored when a cost stat is provided.
+    """
+
+    def validate(val: dict[str, Any]) -> dict[str, Any]:
+        stat_id = val.get(stat_key)
+        if stat_id is not None and not valid_entity_id(stat_id):
+            if val.get(cost_stat_key) is not None:
+                # Cost stat is already set; price fields are ignored, so allow.
+                return val
+            if (
+                val.get(entity_price_key) is not None
+                or val.get(number_price_key) is not None
+            ):
+                raise vol.Invalid(
+                    "Entity or number price is not supported for external"
+                    f" statistics. Use {cost_stat_key} instead"
+                )
+        return val
+
+    return validate
+
+
 def _flow_from_ensure_single_price(
     val: FlowFromGridSourceType,
 ) -> FlowFromGridSourceType:
@@ -268,19 +300,25 @@ FLOW_FROM_GRID_SOURCE_SCHEMA = vol.All(
             vol.Optional("number_energy_price"): vol.Any(vol.Coerce(float), None),
         }
     ),
+    _reject_price_for_external_stat(stat_key="stat_energy_from"),
     _flow_from_ensure_single_price,
 )
 
 
-FLOW_TO_GRID_SOURCE_SCHEMA = vol.Schema(
-    {
-        vol.Required("stat_energy_to"): str,
-        vol.Optional("stat_compensation"): vol.Any(str, None),
-        # entity_energy_to was removed in HA Core 2022.10
-        vol.Remove("entity_energy_to"): vol.Any(str, None),
-        vol.Optional("entity_energy_price"): vol.Any(str, None),
-        vol.Optional("number_energy_price"): vol.Any(vol.Coerce(float), None),
-    }
+FLOW_TO_GRID_SOURCE_SCHEMA = vol.All(
+    vol.Schema(
+        {
+            vol.Required("stat_energy_to"): str,
+            vol.Optional("stat_compensation"): vol.Any(str, None),
+            # entity_energy_to was removed in HA Core 2022.10
+            vol.Remove("entity_energy_to"): vol.Any(str, None),
+            vol.Optional("entity_energy_price"): vol.Any(str, None),
+            vol.Optional("number_energy_price"): vol.Any(vol.Coerce(float), None),
+        }
+    ),
+    _reject_price_for_external_stat(
+        stat_key="stat_energy_to", cost_stat_key="stat_compensation"
+    ),
 )
 
 
@@ -419,6 +457,13 @@ GRID_SOURCE_SCHEMA = vol.All(
             vol.Required("cost_adjustment_day"): vol.Coerce(float),
         }
     ),
+    _reject_price_for_external_stat(stat_key="stat_energy_from"),
+    _reject_price_for_external_stat(
+        stat_key="stat_energy_to",
+        entity_price_key="entity_energy_price_export",
+        number_price_key="number_energy_price_export",
+        cost_stat_key="stat_compensation",
+    ),
     _grid_ensure_single_price_import,
     _grid_ensure_single_price_export,
     _grid_ensure_at_least_one_stat,
@@ -442,27 +487,35 @@ BATTERY_SOURCE_SCHEMA = vol.Schema(
         vol.Optional("power_config"): POWER_CONFIG_SCHEMA,
     }
 )
-GAS_SOURCE_SCHEMA = vol.Schema(
-    {
-        vol.Required("type"): "gas",
-        vol.Required("stat_energy_from"): str,
-        vol.Optional("stat_rate"): str,
-        vol.Optional("stat_cost"): vol.Any(str, None),
-        # entity_energy_from was removed in HA Core 2022.10
-        vol.Remove("entity_energy_from"): vol.Any(str, None),
-        vol.Optional("entity_energy_price"): vol.Any(str, None),
-        vol.Optional("number_energy_price"): vol.Any(vol.Coerce(float), None),
-    }
+
+
+GAS_SOURCE_SCHEMA = vol.All(
+    vol.Schema(
+        {
+            vol.Required("type"): "gas",
+            vol.Required("stat_energy_from"): str,
+            vol.Optional("stat_rate"): str,
+            vol.Optional("stat_cost"): vol.Any(str, None),
+            # entity_energy_from was removed in HA Core 2022.10
+            vol.Remove("entity_energy_from"): vol.Any(str, None),
+            vol.Optional("entity_energy_price"): vol.Any(str, None),
+            vol.Optional("number_energy_price"): vol.Any(vol.Coerce(float), None),
+        }
+    ),
+    _reject_price_for_external_stat(stat_key="stat_energy_from"),
 )
-WATER_SOURCE_SCHEMA = vol.Schema(
-    {
-        vol.Required("type"): "water",
-        vol.Required("stat_energy_from"): str,
-        vol.Optional("stat_rate"): str,
-        vol.Optional("stat_cost"): vol.Any(str, None),
-        vol.Optional("entity_energy_price"): vol.Any(str, None),
-        vol.Optional("number_energy_price"): vol.Any(vol.Coerce(float), None),
-    }
+WATER_SOURCE_SCHEMA = vol.All(
+    vol.Schema(
+        {
+            vol.Required("type"): "water",
+            vol.Required("stat_energy_from"): str,
+            vol.Optional("stat_rate"): str,
+            vol.Optional("stat_cost"): vol.Any(str, None),
+            vol.Optional("entity_energy_price"): vol.Any(str, None),
+            vol.Optional("number_energy_price"): vol.Any(vol.Coerce(float), None),
+        }
+    ),
+    _reject_price_for_external_stat(stat_key="stat_energy_from"),
 )
 
 

homeassistant/components/ezviz/icons.json

@@ -23,6 +23,23 @@
       "alarm_sound_mode": {
         "default": "mdi:alarm"
       }
+    },
+    "sensor": {
+      "alarm_sound_mode": {
+        "default": "mdi:alarm"
+      },
+      "last_alarm_type_code": {
+        "default": "mdi:alarm"
+      },
+      "last_alarm_type_name": {
+        "default": "mdi:alarm"
+      },
+      "local_ip": {
+        "default": "mdi:ip"
+      },
+      "wan_ip": {
+        "default": "mdi:ip"
+      }
     }
   },
   "services": {

homeassistant/components/fritz/config_flow.py

@@ -283,6 +283,7 @@ class FritzBoxToolsFlowHandler(ConfigFlow, domain=DOMAIN):
         self._username = user_input[CONF_USERNAME]
         self._password = user_input[CONF_PASSWORD]
         self._use_tls = user_input[CONF_SSL]
+        self._feature_device_discovery = user_input[CONF_FEATURE_DEVICE_TRACKING]
 
         self._port = self._determine_port(user_input)
 

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

@@ -88,6 +88,9 @@
       },
       "to_foreground": {
         "name": "Bring to foreground"
+      },
+      "trigger_motion": {
+        "name": "Trigger motion activity"
       }
     },
     "image": {

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/config_flow.py

@@ -8,7 +8,11 @@ from typing import Any, cast
 
 from google_drive_api.exceptions import GoogleDriveApiError
 
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    SOURCE_RECONFIGURE,
+    ConfigFlowResult,
+)
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
 from homeassistant.helpers import config_entry_oauth2_flow, instance_id
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -44,6 +48,12 @@ class OAuth2FlowHandler(
             "prompt": "consent",
         }
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a reconfiguration flow."""
+        return await self.async_step_user(user_input)
+
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
@@ -81,13 +91,16 @@ class OAuth2FlowHandler(
 
         await self.async_set_unique_id(email_address)
 
-        if self.source == SOURCE_REAUTH:
-            reauth_entry = self._get_reauth_entry()
+        if self.source in (SOURCE_REAUTH, SOURCE_RECONFIGURE):
+            if self.source == SOURCE_REAUTH:
+                entry = self._get_reauth_entry()
+            else:
+                entry = self._get_reconfigure_entry()
             self._abort_if_unique_id_mismatch(
                 reason="wrong_account",
-                description_placeholders={"email": cast(str, reauth_entry.unique_id)},
+                description_placeholders={"email": cast(str, entry.unique_id)},
             )
-            return self.async_update_reload_and_abort(reauth_entry, data=data)
+            return self.async_update_reload_and_abort(entry, data=data)
 
         self._abort_if_unique_id_configured()
 

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,12 +64,8 @@ rules:
   entity-disabled-by-default: done
   entity-translations: done
   exception-translations: done
-  icon-translations:
-    status: exempt
-    comment: No entities.
-  reconfiguration-flow:
-    status: exempt
-    comment: No configuration options.
+  icon-translations: done
+  reconfiguration-flow: done
   repair-issues:
     status: exempt
     comment: No repairs.

homeassistant/components/google_drive/strings.json

@@ -18,6 +18,7 @@
       "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%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unknown": "[%key:common::config_flow::error::unknown%]",
       "user_rejected_authorize": "[%key:common::config_flow::abort::oauth2_user_rejected_authorize%]",
       "wrong_account": "Wrong account: Please authenticate with {email}."
@@ -62,5 +63,22 @@
         "name": "Used storage in Drive Trash"
       }
     }
+  },
+  "exceptions": {
+    "authentication_failed": {
+      "message": "Authentication failed"
+    },
+    "authentication_not_valid": {
+      "message": "OAuth session is not valid, reauthentication 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/google_weather/coordinator.py

@@ -24,6 +24,8 @@ from homeassistant.helpers.update_coordinator import (
     UpdateFailed,
 )
 
+from .const import DOMAIN
+
 _LOGGER = logging.getLogger(__name__)
 
 T = TypeVar(
@@ -97,7 +99,13 @@ class GoogleWeatherBaseCoordinator(TimestampDataUpdateCoordinator[T]):
                 self.subentry.title,
                 err,
             )
-            raise UpdateFailed(f"Error fetching {self._data_type_name}") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={
+                    "error": str(err),
+                },
+            ) from err
 
 
 class GoogleWeatherCurrentConditionsCoordinator(

homeassistant/components/google_weather/quality_scale.yaml

@@ -66,7 +66,7 @@ rules:
   entity-device-class: done
   entity-disabled-by-default: done
   entity-translations: done
-  exception-translations: todo
+  exception-translations: done
   icon-translations: done
   reconfiguration-flow: todo
   repair-issues:

homeassistant/components/google_weather/strings.json

@@ -98,5 +98,10 @@
         "name": "Wind gust speed"
       }
     }
+  },
+  "exceptions": {
+    "update_error": {
+      "message": "Error fetching weather data: {error}"
+    }
   }
 }

homeassistant/components/growatt_server/coordinator.py

@@ -372,7 +372,8 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         if self.api_version != "v1":
             raise ServiceValidationError(
-                "Updating time segments requires token authentication"
+                translation_domain=DOMAIN,
+                translation_key="token_auth_required",
             )
 
         try:
@@ -388,7 +389,11 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 enabled,
             )
         except growattServer.GrowattV1ApiError as err:
-            raise HomeAssistantError(f"API error updating time segment: {err}") from err
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"error": str(err)},
+            ) from err
 
         # Update coordinator's cached data without making an API call (avoids rate limit)
         if self.data:
@@ -411,7 +416,8 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
         if self.api_version != "v1":
             raise ServiceValidationError(
-                "Reading time segments requires token authentication"
+                translation_domain=DOMAIN,
+                translation_key="token_auth_required",
             )
 
         # Ensure we have current data
@@ -496,7 +502,8 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         """
         if self.api_version != "v1":
             raise ServiceValidationError(
-                "Updating AC charge times requires token authentication"
+                translation_domain=DOMAIN,
+                translation_key="token_auth_required",
             )
 
         try:
@@ -510,7 +517,9 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             )
         except growattServer.GrowattV1ApiError as err:
             raise HomeAssistantError(
-                f"API error updating AC charge times: {err}"
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"error": str(err)},
             ) from err
 
         if self.data:
@@ -544,7 +553,8 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         """
         if self.api_version != "v1":
             raise ServiceValidationError(
-                "Updating AC discharge times requires token authentication"
+                translation_domain=DOMAIN,
+                translation_key="token_auth_required",
             )
 
         try:
@@ -557,7 +567,9 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             )
         except growattServer.GrowattV1ApiError as err:
             raise HomeAssistantError(
-                f"API error updating AC discharge times: {err}"
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"error": str(err)},
             ) from err
 
         if self.data:
@@ -579,7 +591,8 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         """Read AC charge time settings from SPH device cache."""
         if self.api_version != "v1":
             raise ServiceValidationError(
-                "Reading AC charge times requires token authentication"
+                translation_domain=DOMAIN,
+                translation_key="token_auth_required",
             )
 
         if not self.data:
@@ -591,7 +604,8 @@ class GrowattCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         """Read AC discharge time settings from SPH device cache."""
         if self.api_version != "v1":
             raise ServiceValidationError(
-                "Reading AC discharge times requires token authentication"
+                translation_domain=DOMAIN,
+                translation_key="token_auth_required",
             )
 
         if not self.data:

homeassistant/components/growatt_server/diagnostics.py

@@ -0,0 +1,65 @@
+"""Diagnostics support for Growatt Server."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_PASSWORD, CONF_TOKEN, CONF_UNIQUE_ID, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+
+from .const import CONF_PLANT_ID
+from .coordinator import GrowattConfigEntry
+
+TO_REDACT = {
+    CONF_PASSWORD,
+    CONF_TOKEN,
+    CONF_USERNAME,
+    CONF_UNIQUE_ID,
+    CONF_PLANT_ID,
+    "user_id",
+    "deviceSn",
+    "device_sn",
+}
+
+# Allowlist of safe telemetry fields from the total coordinator.
+# Monetary fields (plantMoneyText, totalMoneyText, currency) are intentionally
+# excluded to avoid leaking financial data under unpredictable key names.
+_TOTAL_SAFE_KEYS = frozenset(
+    {
+        # Classic API keys
+        "todayEnergy",
+        "totalEnergy",
+        "invTodayPpv",
+        "nominalPower",
+        # V1 API keys (aliases used after normalisation in coordinator)
+        "today_energy",
+        "total_energy",
+        "current_power",
+    }
+)
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, config_entry: GrowattConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    runtime_data = config_entry.runtime_data
+    total_data = runtime_data.total_coordinator.data or {}
+    return async_redact_data(
+        {
+            "config_entry": config_entry.as_dict(),
+            "total_coordinator": {
+                k: v for k, v in total_data.items() if k in _TOTAL_SAFE_KEYS
+            },
+            "devices": [
+                {
+                    "device_sn": device_sn,
+                    "device_type": coordinator.device_type,
+                    "data": coordinator.data,
+                }
+                for device_sn, coordinator in runtime_data.devices.items()
+            ],
+        },
+        TO_REDACT,
+    )

homeassistant/components/growatt_server/number.py

@@ -158,7 +158,11 @@ class GrowattNumber(CoordinatorEntity[GrowattCoordinator], NumberEntity):
                 int_value,
             )
         except GrowattV1ApiError as e:
-            raise HomeAssistantError(f"Error while setting parameter: {e}") from e
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"error": str(e)},
+            ) from e
 
         # If no exception was raised, the write was successful
         _LOGGER.debug(

homeassistant/components/growatt_server/quality_scale.yaml

@@ -33,7 +33,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: todo
+  diagnostics: done
   discovery-update-info: todo
   discovery: todo
   docs-data-update: todo
@@ -48,7 +48,7 @@ rules:
   entity-device-class: done
   entity-disabled-by-default: done
   entity-translations: done
-  exception-translations: todo
+  exception-translations: done
   icon-translations: done
   reconfiguration-flow: todo
   repair-issues:

homeassistant/components/growatt_server/services.py

@@ -46,15 +46,20 @@ def _get_coordinator(
 
     if not coordinators:
         raise ServiceValidationError(
-            f"No {device_type.upper()} devices with token authentication are configured. "
-            f"Services require {device_type.upper()} devices with V1 API access."
+            translation_domain=DOMAIN,
+            translation_key="no_devices_configured",
+            translation_placeholders={"device_type": device_type.upper()},
         )
 
     device_registry = dr.async_get(hass)
     device_entry = device_registry.async_get(device_id)
 
     if not device_entry:
-        raise ServiceValidationError(f"Device '{device_id}' not found")
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="device_not_found",
+            translation_placeholders={"device_id": device_id},
+        )
 
     serial_number = None
     for identifier in device_entry.identifiers:
@@ -63,11 +68,20 @@ def _get_coordinator(
             break
 
     if not serial_number:
-        raise ServiceValidationError(f"Device '{device_id}' is not a Growatt device")
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="device_not_growatt",
+            translation_placeholders={"device_id": device_id},
+        )
 
     if serial_number not in coordinators:
         raise ServiceValidationError(
-            f"{device_type.upper()} device '{serial_number}' not found or not configured for services"
+            translation_domain=DOMAIN,
+            translation_key="device_not_configured",
+            translation_placeholders={
+                "device_type": device_type.upper(),
+                "serial_number": serial_number,
+            },
         )
 
     return coordinators[serial_number]
@@ -78,13 +92,17 @@ def _parse_time_str(time_str: str, field_name: str) -> time:
     parts = time_str.split(":")
     if len(parts) not in (2, 3):
         raise ServiceValidationError(
-            f"{field_name} must be in HH:MM or HH:MM:SS format"
+            translation_domain=DOMAIN,
+            translation_key="invalid_time_format",
+            translation_placeholders={"field_name": field_name},
         )
     try:
         return datetime.strptime(f"{parts[0]}:{parts[1]}", "%H:%M").time()
     except (ValueError, IndexError) as err:
         raise ServiceValidationError(
-            f"{field_name} must be in HH:MM or HH:MM:SS format"
+            translation_domain=DOMAIN,
+            translation_key="invalid_time_format",
+            translation_placeholders={"field_name": field_name},
         ) from err
 
 
@@ -103,7 +121,9 @@ def async_setup_services(hass: HomeAssistant) -> None:
 
         if not 1 <= segment_id <= 9:
             raise ServiceValidationError(
-                f"segment_id must be between 1 and 9, got {segment_id}"
+                translation_domain=DOMAIN,
+                translation_key="invalid_segment_id",
+                translation_placeholders={"segment_id": str(segment_id)},
             )
 
         valid_modes = {
@@ -113,7 +133,12 @@ def async_setup_services(hass: HomeAssistant) -> None:
         }
         if batt_mode_str not in valid_modes:
             raise ServiceValidationError(
-                f"batt_mode must be one of {list(valid_modes.keys())}, got '{batt_mode_str}'"
+                translation_domain=DOMAIN,
+                translation_key="invalid_batt_mode",
+                translation_placeholders={
+                    "batt_mode": batt_mode_str,
+                    "allowed_modes": ", ".join(valid_modes),
+                },
             )
         batt_mode: int = valid_modes[batt_mode_str]
 
@@ -151,11 +176,15 @@ def async_setup_services(hass: HomeAssistant) -> None:
 
         if not 0 <= charge_power <= 100:
             raise ServiceValidationError(
-                f"charge_power must be between 0 and 100, got {charge_power}"
+                translation_domain=DOMAIN,
+                translation_key="invalid_charge_power",
+                translation_placeholders={"value": str(charge_power)},
             )
         if not 0 <= charge_stop_soc <= 100:
             raise ServiceValidationError(
-                f"charge_stop_soc must be between 0 and 100, got {charge_stop_soc}"
+                translation_domain=DOMAIN,
+                translation_key="invalid_charge_stop_soc",
+                translation_placeholders={"value": str(charge_stop_soc)},
             )
 
         periods = []
@@ -193,11 +222,15 @@ def async_setup_services(hass: HomeAssistant) -> None:
 
         if not 0 <= discharge_power <= 100:
             raise ServiceValidationError(
-                f"discharge_power must be between 0 and 100, got {discharge_power}"
+                translation_domain=DOMAIN,
+                translation_key="invalid_discharge_power",
+                translation_placeholders={"value": str(discharge_power)},
             )
         if not 0 <= discharge_stop_soc <= 100:
             raise ServiceValidationError(
-                f"discharge_stop_soc must be between 0 and 100, got {discharge_stop_soc}"
+                translation_domain=DOMAIN,
+                translation_key="invalid_discharge_stop_soc",
+                translation_placeholders={"value": str(discharge_stop_soc)},
             )
 
         periods = []

homeassistant/components/growatt_server/strings.json

@@ -574,6 +574,47 @@
       }
     }
   },
+  "exceptions": {
+    "api_error": {
+      "message": "Growatt API error: {error}"
+    },
+    "device_not_configured": {
+      "message": "{device_type} device {serial_number} is not configured for services."
+    },
+    "device_not_found": {
+      "message": "Device {device_id} not found in the device registry."
+    },
+    "device_not_growatt": {
+      "message": "Device {device_id} is not a Growatt device."
+    },
+    "invalid_batt_mode": {
+      "message": "{batt_mode} is not a valid battery mode. Allowed values: {allowed_modes}."
+    },
+    "invalid_charge_power": {
+      "message": "charge_power must be between 0 and 100, got {value}."
+    },
+    "invalid_charge_stop_soc": {
+      "message": "charge_stop_soc must be between 0 and 100, got {value}."
+    },
+    "invalid_discharge_power": {
+      "message": "discharge_power must be between 0 and 100, got {value}."
+    },
+    "invalid_discharge_stop_soc": {
+      "message": "discharge_stop_soc must be between 0 and 100, got {value}."
+    },
+    "invalid_segment_id": {
+      "message": "segment_id must be between 1 and 9, got {segment_id}."
+    },
+    "invalid_time_format": {
+      "message": "{field_name} must be in HH:MM or HH:MM:SS format."
+    },
+    "no_devices_configured": {
+      "message": "No {device_type} devices with token authentication are configured. Actions require {device_type} devices with V1 API access."
+    },
+    "token_auth_required": {
+      "message": "This action requires token authentication (V1 API)."
+    }
+  },
   "selector": {
     "batt_mode": {
       "options": {

homeassistant/components/growatt_server/switch.py

@@ -125,7 +125,11 @@ class GrowattSwitch(CoordinatorEntity[GrowattCoordinator], SwitchEntity):
                 api_value,
             )
         except GrowattV1ApiError as e:
-            raise HomeAssistantError(f"Error while setting switch state: {e}") from e
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"error": str(e)},
+            ) from e
 
         # If no exception was raised, the write was successful
         _LOGGER.debug(

homeassistant/components/hassio/__init__.py

@@ -119,7 +119,6 @@ from .coordinator import (
     get_core_stats,
     get_host_info,
     get_info,
-    get_issues_info,
     get_network_info,
     get_os_info,
     get_store,
@@ -158,7 +157,6 @@ __all__ = [
     "get_core_stats",
     "get_host_info",
     "get_info",
-    "get_issues_info",
     "get_network_info",
     "get_os_info",
     "get_store",

homeassistant/components/hassio/issues.py

@@ -92,6 +92,7 @@ ISSUE_KEYS_FOR_REPAIRS = {
     ISSUE_KEY_SYSTEM_FREE_SPACE,
     ISSUE_KEY_ADDON_PWNED,
     ISSUE_KEY_ADDON_DEPRECATED_ARCH,
+    "issue_system_ntp_sync_failed",
 }
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/hassio/repairs.py

@@ -15,7 +15,7 @@ from homeassistant.const import ATTR_NAME
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResult
 
-from . import get_addons_list, get_issues_info
+from . import get_addons_list
 from .const import (
     ATTR_SLUG,
     EXTRA_PLACEHOLDERS,
@@ -31,6 +31,7 @@ from .const import (
     PLACEHOLDER_KEY_COMPONENTS,
     PLACEHOLDER_KEY_REFERENCE,
 )
+from .coordinator import get_issues_info
 from .handler import get_supervisor_client
 from .issues import Issue, Suggestion
 

homeassistant/components/hassio/strings.json

@@ -177,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/hikvision/__init__.py

@@ -117,13 +117,21 @@ async def async_setup_entry(hass: HomeAssistant, entry: HikvisionConfigEntry) ->
                 # Map raw event type names to friendly names using SENSOR_MAP
                 mapped_events: dict[str, list[int]] = {}
                 for event_type, channels in nvr_events.items():
-                    friendly_name = SENSOR_MAP.get(event_type.lower(), event_type)
+                    event_key = event_type.lower()
+                    # Skip videoloss - used as watchdog by pyhik, not a real sensor
+                    if event_key == "videoloss":
+                        continue
+                    friendly_name = SENSOR_MAP.get(event_key)
+                    if friendly_name is None:
+                        _LOGGER.debug("Skipping unmapped event type: %s", event_type)
+                        continue
                     if friendly_name in mapped_events:
                         mapped_events[friendly_name].extend(channels)
                     else:
                         mapped_events[friendly_name] = list(channels)
                 _LOGGER.debug("Mapped NVR events: %s", mapped_events)
-                camera.inject_events(mapped_events)
+                if mapped_events:
+                    camera.inject_events(mapped_events)
             else:
                 _LOGGER.debug(
                     "No event triggers returned from %s. "

homeassistant/components/home_connect/manifest.json

@@ -23,6 +23,6 @@
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
   "quality_scale": "platinum",
-  "requirements": ["aiohomeconnect==0.32.0"],
+  "requirements": ["aiohomeconnect==0.33.0"],
   "zeroconf": ["_homeconnect._tcp.local."]
 }

homeassistant/components/home_connect/services.yaml

@@ -119,6 +119,10 @@ set_program_and_options:
             - cooking_common_program_hood_automatic
             - cooking_common_program_hood_venting
             - cooking_common_program_hood_delayed_shut_off
+            - cooking_oven_program_heating_mode_3_d_heating
+            - cooking_oven_program_heating_mode_air_fry
+            - cooking_oven_program_heating_mode_grill_large_area
+            - cooking_oven_program_heating_mode_grill_small_area
             - cooking_oven_program_heating_mode_pre_heating
             - cooking_oven_program_heating_mode_hot_air
             - cooking_oven_program_heating_mode_hot_air_eco

homeassistant/components/home_connect/strings.json

@@ -260,12 +260,16 @@
           "cooking_common_program_hood_automatic": "[%key:component::home_connect::selector::programs::options::cooking_common_program_hood_automatic%]",
           "cooking_common_program_hood_delayed_shut_off": "[%key:component::home_connect::selector::programs::options::cooking_common_program_hood_delayed_shut_off%]",
           "cooking_common_program_hood_venting": "[%key:component::home_connect::selector::programs::options::cooking_common_program_hood_venting%]",
+          "cooking_oven_program_heating_mode_3_d_heating": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_3_d_heating%]",
+          "cooking_oven_program_heating_mode_air_fry": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_air_fry%]",
           "cooking_oven_program_heating_mode_bottom_heating": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_bottom_heating%]",
           "cooking_oven_program_heating_mode_bread_baking": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_bread_baking%]",
           "cooking_oven_program_heating_mode_defrost": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_defrost%]",
           "cooking_oven_program_heating_mode_desiccation": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_desiccation%]",
           "cooking_oven_program_heating_mode_dough_proving": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_dough_proving%]",
           "cooking_oven_program_heating_mode_frozen_heatup_special": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_frozen_heatup_special%]",
+          "cooking_oven_program_heating_mode_grill_large_area": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_grill_large_area%]",
+          "cooking_oven_program_heating_mode_grill_small_area": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_grill_small_area%]",
           "cooking_oven_program_heating_mode_hot_air": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air%]",
           "cooking_oven_program_heating_mode_hot_air_100_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_100_steam%]",
           "cooking_oven_program_heating_mode_hot_air_30_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_30_steam%]",
@@ -616,12 +620,16 @@
           "cooking_common_program_hood_automatic": "[%key:component::home_connect::selector::programs::options::cooking_common_program_hood_automatic%]",
           "cooking_common_program_hood_delayed_shut_off": "[%key:component::home_connect::selector::programs::options::cooking_common_program_hood_delayed_shut_off%]",
           "cooking_common_program_hood_venting": "[%key:component::home_connect::selector::programs::options::cooking_common_program_hood_venting%]",
+          "cooking_oven_program_heating_mode_3_d_heating": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_3_d_heating%]",
+          "cooking_oven_program_heating_mode_air_fry": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_air_fry%]",
           "cooking_oven_program_heating_mode_bottom_heating": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_bottom_heating%]",
           "cooking_oven_program_heating_mode_bread_baking": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_bread_baking%]",
           "cooking_oven_program_heating_mode_defrost": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_defrost%]",
           "cooking_oven_program_heating_mode_desiccation": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_desiccation%]",
           "cooking_oven_program_heating_mode_dough_proving": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_dough_proving%]",
           "cooking_oven_program_heating_mode_frozen_heatup_special": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_frozen_heatup_special%]",
+          "cooking_oven_program_heating_mode_grill_large_area": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_grill_large_area%]",
+          "cooking_oven_program_heating_mode_grill_small_area": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_grill_small_area%]",
           "cooking_oven_program_heating_mode_hot_air": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air%]",
           "cooking_oven_program_heating_mode_hot_air_100_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_100_steam%]",
           "cooking_oven_program_heating_mode_hot_air_30_steam": "[%key:component::home_connect::selector::programs::options::cooking_oven_program_heating_mode_hot_air_30_steam%]",
@@ -1621,12 +1629,16 @@
         "cooking_common_program_hood_automatic": "Automatic",
         "cooking_common_program_hood_delayed_shut_off": "Delayed shut off",
         "cooking_common_program_hood_venting": "Venting",
+        "cooking_oven_program_heating_mode_3_d_heating": "3D heating",
+        "cooking_oven_program_heating_mode_air_fry": "Air fry",
         "cooking_oven_program_heating_mode_bottom_heating": "Bottom heating",
         "cooking_oven_program_heating_mode_bread_baking": "Bread baking",
         "cooking_oven_program_heating_mode_defrost": "Defrost",
         "cooking_oven_program_heating_mode_desiccation": "Desiccation",
         "cooking_oven_program_heating_mode_dough_proving": "Dough proving",
         "cooking_oven_program_heating_mode_frozen_heatup_special": "Special heat-up for frozen products",
+        "cooking_oven_program_heating_mode_grill_large_area": "Grill (large area)",
+        "cooking_oven_program_heating_mode_grill_small_area": "Grill (small area)",
         "cooking_oven_program_heating_mode_hot_air": "Hot air",
         "cooking_oven_program_heating_mode_hot_air_100_steam": "Hot air + 100 RH",
         "cooking_oven_program_heating_mode_hot_air_30_steam": "Hot air + 30 RH",

homeassistant/components/homematicip_cloud/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["homematicip"],
-  "requirements": ["homematicip==2.6.0"]
+  "requirements": ["homematicip==2.7.0"]
 }

homeassistant/components/huum/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -57,3 +58,48 @@ class HuumConfigFlow(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauthentication 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:
+        """Confirm reauthentication dialog."""
+        errors: dict[str, str] = {}
+        reauth_entry = self._get_reauth_entry()
+
+        if user_input is not None:
+            huum = Huum(
+                reauth_entry.data[CONF_USERNAME],
+                user_input[CONF_PASSWORD],
+                session=async_get_clientsession(self.hass),
+            )
+            try:
+                await huum.status()
+            except Forbidden, NotAuthenticated:
+                errors["base"] = "invalid_auth"
+            except Exception:
+                _LOGGER.exception("Unknown error")
+                errors["base"] = "unknown"
+            else:
+                return self.async_update_reload_and_abort(
+                    reauth_entry,
+                    data_updates={CONF_PASSWORD: user_input[CONF_PASSWORD]},
+                )
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PASSWORD): str,
+                }
+            ),
+            description_placeholders={
+                "username": reauth_entry.data[CONF_USERNAME],
+            },
+            errors=errors,
+        )

homeassistant/components/huum/coordinator.py

@@ -12,8 +12,9 @@ from huum.schemas import HuumStatusResponse
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .const import DOMAIN
 
@@ -54,6 +55,6 @@ class HuumDataUpdateCoordinator(DataUpdateCoordinator[HuumStatusResponse]):
         try:
             return await self.huum.status()
         except (Forbidden, NotAuthenticated) as err:
-            raise UpdateFailed(
+            raise ConfigEntryAuthFailed(
                 "Could not log in to Huum with given credentials"
             ) from err

homeassistant/components/huum/quality_scale.yaml

@@ -38,7 +38,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: todo
+  reauthentication-flow: done
   test-coverage:
     status: todo
     comment: |

homeassistant/components/huum/strings.json

@@ -1,7 +1,8 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -9,6 +10,16 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
+      "reauth_confirm": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "[%key:component::huum::config::step::user::data_description::password%]"
+        },
+        "description": "The authentication for {username} is no longer valid. Please enter the current password.",
+        "title": "[%key:common::config_flow::title::reauth%]"
+      },
       "user": {
         "data": {
           "password": "[%key:common::config_flow::data::password%]",

homeassistant/components/hypontech/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["hyponcloud==0.3.0"]
+  "requirements": ["hyponcloud==0.9.0"]
 }

homeassistant/components/hypontech/sensor.py

@@ -21,11 +21,17 @@ from .coordinator import HypontechConfigEntry, HypontechDataCoordinator
 from .entity import HypontechEntity, HypontechPlantEntity
 
 
+def _power_unit(data: OverviewData | PlantData) -> str:
+    """Return the unit of measurement for power based on the API unit."""
+    return UnitOfPower.KILO_WATT if data.company.upper() == "KW" else UnitOfPower.WATT
+
+
 @dataclass(frozen=True, kw_only=True)
 class HypontechSensorDescription(SensorEntityDescription):
     """Describes Hypontech overview sensor entity."""
 
     value_fn: Callable[[OverviewData], float | None]
+    unit_fn: Callable[[OverviewData], str] | None = None
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -33,15 +39,16 @@ class HypontechPlantSensorDescription(SensorEntityDescription):
     """Describes Hypontech plant sensor entity."""
 
     value_fn: Callable[[PlantData], float | None]
+    unit_fn: Callable[[PlantData], str] | None = None
 
 
 OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
     HypontechSensorDescription(
         key="pv_power",
-        native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
         value_fn=lambda c: c.power,
+        unit_fn=_power_unit,
     ),
     HypontechSensorDescription(
         key="lifetime_energy",
@@ -64,10 +71,10 @@ OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
 PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
     HypontechPlantSensorDescription(
         key="pv_power",
-        native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
         value_fn=lambda c: c.power,
+        unit_fn=_power_unit,
     ),
     HypontechPlantSensorDescription(
         key="lifetime_energy",
@@ -124,6 +131,13 @@ class HypontechOverviewSensor(HypontechEntity, SensorEntity):
         self.entity_description = description
         self._attr_unique_id = f"{coordinator.account_id}_{description.key}"
 
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        """Return the unit of measurement."""
+        if self.entity_description.unit_fn is not None:
+            return self.entity_description.unit_fn(self.coordinator.data.overview)
+        return super().native_unit_of_measurement
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
@@ -146,6 +160,13 @@ class HypontechPlantSensor(HypontechPlantEntity, SensorEntity):
         self.entity_description = description
         self._attr_unique_id = f"{plant_id}_{description.key}"
 
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        """Return the unit of measurement."""
+        if self.entity_description.unit_fn is not None:
+            return self.entity_description.unit_fn(self.plant)
+        return super().native_unit_of_measurement
+
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""

homeassistant/components/lichess/__init__.py

@@ -0,0 +1,31 @@
+"""The Lichess integration."""
+
+from __future__ import annotations
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import LichessConfigEntry, LichessCoordinator
+
+_PLATFORMS: list[Platform] = [
+    Platform.SENSOR,
+]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: LichessConfigEntry) -> bool:
+    """Set up Lichess from a config entry."""
+
+    coordinator = LichessCoordinator(hass, entry)
+
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: LichessConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, _PLATFORMS)

homeassistant/components/lichess/config_flow.py

@@ -0,0 +1,52 @@
+"""Config flow for the Lichess integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from aiolichess import AioLichess
+from aiolichess.exceptions import AioLichessError, AuthError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_TOKEN
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class LichessConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Lichess."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            session = async_get_clientsession(self.hass)
+            client = AioLichess(session=session)
+            try:
+                user = await client.get_all(token=user_input[CONF_API_TOKEN])
+            except AuthError:
+                errors["base"] = "invalid_auth"
+            except AioLichessError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                username = user.username
+                player_id = user.id
+                await self.async_set_unique_id(player_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title=username, data=user_input)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema({vol.Required(CONF_API_TOKEN): str}),
+            errors=errors,
+        )

homeassistant/components/lichess/const.py

@@ -0,0 +1,3 @@
+"""Constants for the Lichess integration."""
+
+DOMAIN = "lichess"

homeassistant/components/lichess/coordinator.py

@@ -0,0 +1,44 @@
+"""Coordinator for Lichess."""
+
+from datetime import timedelta
+import logging
+
+from aiolichess import AioLichess
+from aiolichess.exceptions import AioLichessError
+from aiolichess.models import LichessStatistics
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_TOKEN
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+_LOGGER = logging.getLogger(__name__)
+
+type LichessConfigEntry = ConfigEntry[LichessCoordinator]
+
+
+class LichessCoordinator(DataUpdateCoordinator[LichessStatistics]):
+    """Coordinator for Lichess."""
+
+    config_entry: LichessConfigEntry
+
+    def __init__(self, hass: HomeAssistant, config_entry: LichessConfigEntry) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=config_entry.title,
+            update_interval=timedelta(hours=1),
+        )
+        self.client = AioLichess(session=async_get_clientsession(hass))
+
+    async def _async_update_data(self) -> LichessStatistics:
+        """Update data for Lichess."""
+        try:
+            return await self.client.get_statistics(
+                token=self.config_entry.data[CONF_API_TOKEN]
+            )
+        except AioLichessError as err:
+            raise UpdateFailed("Error in communicating with Lichess") from err

homeassistant/components/lichess/entity.py

@@ -0,0 +1,26 @@
+"""Base entity for Lichess integration."""
+
+from typing import TYPE_CHECKING
+
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import LichessCoordinator
+
+
+class LichessEntity(CoordinatorEntity[LichessCoordinator]):
+    """Base entity for Lichess integration."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: LichessCoordinator) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        if TYPE_CHECKING:
+            assert coordinator.config_entry.unique_id is not None
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, coordinator.config_entry.unique_id)},
+            entry_type=DeviceEntryType.SERVICE,
+            manufacturer="Lichess",
+        )

homeassistant/components/lichess/icons.json

@@ -0,0 +1,30 @@
+{
+  "entity": {
+    "sensor": {
+      "blitz_games": {
+        "default": "mdi:chess-pawn"
+      },
+      "blitz_rating": {
+        "default": "mdi:chart-line"
+      },
+      "bullet_games": {
+        "default": "mdi:chess-pawn"
+      },
+      "bullet_rating": {
+        "default": "mdi:chart-line"
+      },
+      "classical_games": {
+        "default": "mdi:chess-pawn"
+      },
+      "classical_rating": {
+        "default": "mdi:chart-line"
+      },
+      "rapid_games": {
+        "default": "mdi:chess-pawn"
+      },
+      "rapid_rating": {
+        "default": "mdi:chart-line"
+      }
+    }
+  }
+}

homeassistant/components/lichess/manifest.json

@@ -0,0 +1,11 @@
+{
+  "domain": "lichess",
+  "name": "Lichess",
+  "codeowners": ["@aryanhasgithub"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/lichess",
+  "integration_type": "service",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["aiolichess==1.2.0"]
+}

homeassistant/components/lichess/quality_scale.yaml

@@ -0,0 +1,72 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: There are no custom actions present
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow: done
+  config-flow-test-coverage: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: There are no custom actions present
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: The entities do not explicitly subscribe to events
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: There are no custom actions
+  config-entry-unloading: done
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: todo
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: The integration does not use discovery
+  discovery:
+    status: exempt
+    comment: The integration does not use discovery
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

homeassistant/components/lichess/sensor.py

@@ -0,0 +1,116 @@
+"""Sensor platform for Lichess integration."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from aiolichess.models import LichessStatistics
+
+from homeassistant.components.sensor import (
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import LichessConfigEntry
+from .coordinator import LichessCoordinator
+from .entity import LichessEntity
+
+
+@dataclass(kw_only=True, frozen=True)
+class LichessEntityDescription(SensorEntityDescription):
+    """Sensor description for Lichess player."""
+
+    value_fn: Callable[[LichessStatistics], int | None]
+
+
+SENSORS: tuple[LichessEntityDescription, ...] = (
+    LichessEntityDescription(
+        key="bullet_rating",
+        translation_key="bullet_rating",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda state: state.bullet_rating,
+    ),
+    LichessEntityDescription(
+        key="bullet_games",
+        translation_key="bullet_games",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda state: state.bullet_games,
+    ),
+    LichessEntityDescription(
+        key="blitz_rating",
+        translation_key="blitz_rating",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda state: state.blitz_rating,
+    ),
+    LichessEntityDescription(
+        key="blitz_games",
+        translation_key="blitz_games",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda state: state.blitz_games,
+    ),
+    LichessEntityDescription(
+        key="rapid_rating",
+        translation_key="rapid_rating",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda state: state.rapid_rating,
+    ),
+    LichessEntityDescription(
+        key="rapid_games",
+        translation_key="rapid_games",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda state: state.rapid_games,
+    ),
+    LichessEntityDescription(
+        key="classical_rating",
+        translation_key="classical_rating",
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda state: state.classical_rating,
+    ),
+    LichessEntityDescription(
+        key="classical_games",
+        translation_key="classical_games",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda state: state.classical_games,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: LichessConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Initialize the entries."""
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        LichessPlayerSensor(coordinator, description) for description in SENSORS
+    )
+
+
+class LichessPlayerSensor(LichessEntity, SensorEntity):
+    """Lichess sensor."""
+
+    entity_description: LichessEntityDescription
+
+    def __init__(
+        self,
+        coordinator: LichessCoordinator,
+        description: LichessEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.config_entry.unique_id}.{description.key}"
+
+    @property
+    def native_value(self) -> int | None:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self.coordinator.data)

homeassistant/components/lichess/strings.json

@@ -0,0 +1,54 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "api_token": "[%key:common::config_flow::data::api_token%]"
+        },
+        "data_description": {
+          "api_token": "The Lichess API token of the player."
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "blitz_games": {
+        "name": "Blitz games",
+        "unit_of_measurement": "[%key:component::lichess::entity::sensor::bullet_games::unit_of_measurement%]"
+      },
+      "blitz_rating": {
+        "name": "Blitz rating"
+      },
+      "bullet_games": {
+        "name": "Bullet games",
+        "unit_of_measurement": "games"
+      },
+      "bullet_rating": {
+        "name": "Bullet rating"
+      },
+      "classical_games": {
+        "name": "Classical games",
+        "unit_of_measurement": "[%key:component::lichess::entity::sensor::bullet_games::unit_of_measurement%]"
+      },
+      "classical_rating": {
+        "name": "Classical rating"
+      },
+      "rapid_games": {
+        "name": "Rapid games",
+        "unit_of_measurement": "[%key:component::lichess::entity::sensor::bullet_games::unit_of_measurement%]"
+      },
+      "rapid_rating": {
+        "name": "Rapid rating"
+      }
+    }
+  }
+}

homeassistant/components/liebherr/__init__.py

@@ -15,6 +15,7 @@ from pyliebherrhomeapi.exceptions import (
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.event import async_track_time_interval
@@ -83,6 +84,28 @@ async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) ->
             _LOGGER.exception("Unexpected error scanning for new devices")
             return
 
+        # Remove stale devices no longer returned by the API
+        current_device_ids = {device.device_id for device in devices}
+        device_registry = dr.async_get(hass)
+        for device_entry in dr.async_entries_for_config_entry(
+            device_registry, entry.entry_id
+        ):
+            device_ids = {
+                identifier[1]
+                for identifier in device_entry.identifiers
+                if identifier[0] == DOMAIN
+            }
+            if device_ids - current_device_ids:
+                # Shut down coordinator if one exists
+                for device_id in device_ids:
+                    if coordinator := data.coordinators.pop(device_id, None):
+                        await coordinator.async_shutdown()
+                device_registry.async_update_device(
+                    device_id=device_entry.id,
+                    remove_config_entry_id=entry.entry_id,
+                )
+
+        # Add new devices
         new_coordinators: list[LiebherrCoordinator] = []
         for device in devices:
             if device.device_id not in data.coordinators:

homeassistant/components/liebherr/manifest.json

@@ -7,8 +7,8 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["pyliebherrhomeapi"],
-  "quality_scale": "silver",
-  "requirements": ["pyliebherrhomeapi==0.3.0"],
+  "quality_scale": "gold",
+  "requirements": ["pyliebherrhomeapi==0.4.0"],
   "zeroconf": [
     {
       "name": "liebherr*",

homeassistant/components/liebherr/quality_scale.yaml

@@ -68,7 +68,7 @@ rules:
   repair-issues:
     status: exempt
     comment: No repair issues to implement at this time.
-  stale-devices: todo
+  stale-devices: done
 
   # Platinum
   async-dependency: done

homeassistant/components/liebherr/select.py

@@ -199,15 +199,15 @@ class LiebherrSelectEntity(LiebherrEntity, SelectEntity):
     def _select_control(self) -> SelectControl | None:
         """Get the select control for this entity."""
         for control in self.coordinator.data.controls:
+            if not isinstance(
+                control,
+                IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
+            ):
+                continue
             if (
                 isinstance(control, self.entity_description.control_type)
                 and control.zone_id == self._zone_id
             ):
-                if TYPE_CHECKING:
-                    assert isinstance(
-                        control,
-                        IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
-                    )
                 return control
         return None
 

homeassistant/components/mold_indicator/sensor.py

@@ -214,12 +214,7 @@ class MoldIndicator(SensorEntity):
         # Replay current state of source entities
         for entity_id in self._entities.values():
             state = self.hass.states.get(entity_id)
-            state_event: Event[EventStateChangedData] = Event(
-                "", {"entity_id": entity_id, "new_state": state, "old_state": None}
-            )
-            self._async_mold_indicator_sensor_state_listener(
-                state_event, update_state=False
-            )
+            self._update_cached_values(entity_id, state)
 
         self._recalculate()
 
@@ -227,9 +222,19 @@ class MoldIndicator(SensorEntity):
             calculated_state = self._async_calculate_state()
             self._preview_callback(calculated_state.state, calculated_state.attributes)
 
+    @callback
+    def _update_cached_values(self, entity_id: str, new_state: State | None) -> None:
+        """Update cached sensor values from a state."""
+        if entity_id == self._entities[CONF_INDOOR_TEMP]:
+            self._indoor_temp = self._get_temperature_from_state(new_state)
+        elif entity_id == self._entities[CONF_OUTDOOR_TEMP]:
+            self._outdoor_temp = self._get_temperature_from_state(new_state)
+        elif entity_id == self._entities[CONF_INDOOR_HUMIDITY]:
+            self._indoor_hum = self._get_humidity_from_state(new_state)
+
     @callback
     def _async_mold_indicator_sensor_state_listener(
-        self, event: Event[EventStateChangedData], update_state: bool = True
+        self, event: Event[EventStateChangedData]
     ) -> None:
         """Handle state changes for dependent sensors."""
         entity_id = event.data["entity_id"]
@@ -242,16 +247,7 @@ class MoldIndicator(SensorEntity):
             new_state,
         )
 
-        # update state depending on which sensor changed
-        if entity_id == self._entities[CONF_INDOOR_TEMP]:
-            self._indoor_temp = self._get_temperature_from_state(new_state)
-        elif entity_id == self._entities[CONF_OUTDOOR_TEMP]:
-            self._outdoor_temp = self._get_temperature_from_state(new_state)
-        elif entity_id == self._entities[CONF_INDOOR_HUMIDITY]:
-            self._indoor_hum = self._get_humidity_from_state(new_state)
-
-        if not update_state:
-            return
+        self._update_cached_values(entity_id, new_state)
 
         self._recalculate()
 

homeassistant/components/mqtt/diagnostics.py

@@ -13,7 +13,7 @@ from homeassistant.const import (
     CONF_PASSWORD,
     CONF_USERNAME,
 )
-from homeassistant.core import HomeAssistant, callback, split_entity_id
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.device_registry import DeviceEntry
 
@@ -103,10 +103,8 @@ def _async_device_as_dict(hass: HomeAssistant, device: DeviceEntry) -> dict[str,
         # The context doesn't provide useful information in this case.
         state_dict.pop("context", None)
 
-        entity_domain = split_entity_id(state.entity_id)[0]
-
         # Retract some sensitive state attributes
-        if entity_domain == device_tracker.DOMAIN:
+        if state.domain == device_tracker.DOMAIN:
             state_dict["attributes"] = async_redact_data(
                 state_dict["attributes"], REDACT_STATE_DEVICE_TRACKER
             )

homeassistant/components/ohme/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
-  "requirements": ["ohme==1.7.0"]
+  "requirements": ["ohme==1.7.1"]
 }

homeassistant/components/opower/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["opower"],
   "quality_scale": "platinum",
-  "requirements": ["opower==0.17.0"]
+  "requirements": ["opower==0.17.1"]
 }

homeassistant/components/plugwise/coordinator.py

@@ -65,6 +65,7 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
         )
         self._connected: bool = False
         self._current_devices: set[str] = set()
+        self._firmware_list: dict[str, str | None] = {}
         self._stored_devices: set[str] = set()
         self.new_devices: set[str] = set()
 
@@ -129,6 +130,7 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
             ) from err
 
         self._add_remove_devices(data)
+        self._update_device_firmware(data)
         return data
 
     def _add_remove_devices(self, data: dict[str, GwEntityData]) -> None:
@@ -138,6 +140,9 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
         # 'new_devices' contains all devices present in 'data' at init ('self._current_devices' is empty)
         # this is required for the proper initialization of all the present platform entities.
         self.new_devices = set_of_data - self._current_devices
+        for device_id in self.new_devices:
+            self._firmware_list.setdefault(device_id, data[device_id].get("firmware"))
+
         current_devices = (
             self._stored_devices if not self._current_devices else self._current_devices
         )
@@ -149,21 +154,52 @@ class PlugwiseDataUpdateCoordinator(DataUpdateCoordinator[dict[str, GwEntityData
         """Clean registries when removed devices found."""
         device_reg = dr.async_get(self.hass)
         for device_id in removed_devices:
-            device_entry = device_reg.async_get_device({(DOMAIN, device_id)})
-            if device_entry is None:
-                LOGGER.warning(
-                    "Failed to remove %s device/zone %s, not present in device_registry",
+            if (
+                device_entry := device_reg.async_get_device({(DOMAIN, device_id)})
+            ) is not None:
+                device_reg.async_update_device(
+                    device_entry.id, remove_config_entry_id=self.config_entry.entry_id
+                )
+                LOGGER.debug(
+                    "%s %s %s removed from device_registry",
                     DOMAIN,
+                    device_entry.model,
                     device_id,
                 )
-                continue  # pragma: no cover
 
-            device_reg.async_update_device(
-                device_entry.id, remove_config_entry_id=self.config_entry.entry_id
-            )
+            self._firmware_list.pop(device_id, None)
+
+    def _update_device_firmware(self, data: dict[str, GwEntityData]) -> None:
+        """Detect firmware changes and update the device registry."""
+        for device_id, device in data.items():
+            # Only update firmware when the key is present and not None, to avoid
+            # wiping stored firmware on partial or transient updates.
+            if "firmware" not in device:
+                continue
+            new_firmware = device.get("firmware")
+            if new_firmware is None:
+                continue
+            if (
+                device_id in self._firmware_list
+                and new_firmware != self._firmware_list[device_id]
+            ):
+                updated = self._update_firmware_in_dr(device_id, new_firmware)
+                if updated:
+                    self._firmware_list[device_id] = new_firmware
+
+    def _update_firmware_in_dr(self, device_id: str, firmware: str | None) -> bool:
+        """Update device sw_version in device_registry."""
+        device_reg = dr.async_get(self.hass)
+        if (
+            device_entry := device_reg.async_get_device({(DOMAIN, device_id)})
+        ) is not None:
+            device_reg.async_update_device(device_entry.id, sw_version=firmware)
             LOGGER.debug(
-                "%s %s %s removed from device_registry",
+                "Firmware in device_registry updated for %s %s %s",
                 DOMAIN,
                 device_entry.model,
                 device_id,
             )
+            return True
+
+        return False  # pragma: no cover

homeassistant/components/portainer/button.py

@@ -74,6 +74,26 @@ CONTAINER_BUTTONS: tuple[PortainerButtonDescription, ...] = (
             )
         ),
     ),
+    PortainerButtonDescription(
+        key="pause",
+        translation_key="pause_container",
+        entity_category=EntityCategory.CONFIG,
+        press_action=(
+            lambda portainer, endpoint_id, container_id: portainer.pause_container(
+                endpoint_id, container_id
+            )
+        ),
+    ),
+    PortainerButtonDescription(
+        key="resume",
+        translation_key="resume_container",
+        entity_category=EntityCategory.CONFIG,
+        press_action=(
+            lambda portainer, endpoint_id, container_id: portainer.unpause_container(
+                endpoint_id, container_id
+            )
+        ),
+    ),
 )
 
 

homeassistant/components/portainer/icons.json

@@ -1,5 +1,13 @@
 {
   "entity": {
+    "button": {
+      "pause_container": {
+        "default": "mdi:pause-circle"
+      },
+      "resume_container": {
+        "default": "mdi:play"
+      }
+    },
     "sensor": {
       "api_version": {
         "default": "mdi:api"

homeassistant/components/portainer/strings.json

@@ -66,8 +66,14 @@
       "images_prune": {
         "name": "Prune unused images"
       },
+      "pause_container": {
+        "name": "Pause container"
+      },
       "restart_container": {
         "name": "Restart container"
+      },
+      "resume_container": {
+        "name": "Resume container"
       }
     },
     "sensor": {

homeassistant/components/satel_integra/config_flow.py

@@ -44,11 +44,9 @@ CONNECTION_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_HOST): str,
         vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port,
-        vol.Optional(CONF_CODE): cv.string,
     }
 )
 
-
 CODE_SCHEMA = vol.Schema(
     {
         vol.Optional(CONF_CODE): cv.string,
@@ -86,6 +84,11 @@ SWITCHABLE_OUTPUT_SCHEMA = vol.Schema({vol.Required(CONF_NAME): cv.string})
 class SatelConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a Satel Integra config flow."""
 
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        super().__init__()
+        self.connection_data: dict[str, Any] = {}
+
     VERSION = 2
     MINOR_VERSION = 1
 
@@ -119,24 +122,71 @@ class SatelConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
 
-            valid = await self.test_connection(
-                user_input[CONF_HOST], user_input[CONF_PORT]
-            )
-
-            if valid:
-                return self.async_create_entry(
-                    title=user_input[CONF_HOST],
-                    data={
-                        CONF_HOST: user_input[CONF_HOST],
-                        CONF_PORT: user_input[CONF_PORT],
-                    },
-                    options={CONF_CODE: user_input.get(CONF_CODE)},
-                )
+            if await self.test_connection(user_input[CONF_HOST], user_input[CONF_PORT]):
+                self.connection_data = {
+                    CONF_HOST: user_input[CONF_HOST],
+                    CONF_PORT: user_input[CONF_PORT],
+                }
+                return await self.async_step_code()
 
             errors["base"] = "cannot_connect"
 
         return self.async_show_form(
-            step_id="user", data_schema=CONNECTION_SCHEMA, errors=errors
+            step_id="user",
+            data_schema=CONNECTION_SCHEMA,
+            errors=errors,
+        )
+
+    async def async_step_code(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle code configuration."""
+        if user_input is not None:
+            return self.async_create_entry(
+                title=self.connection_data[CONF_HOST],
+                data=self.connection_data,
+                options={CONF_CODE: user_input.get(CONF_CODE)},
+            )
+
+        return self.async_show_form(
+            step_id="code",
+            data_schema=CODE_SCHEMA,
+        )
+
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration."""
+        errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+
+        if user_input is not None:
+            self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
+
+            if await self.test_connection(user_input[CONF_HOST], user_input[CONF_PORT]):
+                return self.async_update_reload_and_abort(
+                    reconfigure_entry,
+                    data_updates={
+                        CONF_HOST: user_input[CONF_HOST],
+                        CONF_PORT: user_input[CONF_PORT],
+                    },
+                    title=user_input[CONF_HOST],
+                    reload_even_if_entry_is_unchanged=False,
+                )
+
+            errors["base"] = "cannot_connect"
+
+        suggested_values: dict[str, Any] = {
+            **reconfigure_entry.data,
+            **(user_input or {}),
+        }
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=self.add_suggested_values_to_schema(
+                CONNECTION_SCHEMA, suggested_values
+            ),
+            errors=errors,
         )
 
     async def test_connection(self, host: str, port: int) -> bool:

homeassistant/components/satel_integra/strings.json

@@ -5,20 +5,37 @@
   },
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
     },
     "step": {
-      "user": {
+      "code": {
+        "data": {
+          "code": "[%key:component::satel_integra::common::code%]"
+        },
+        "data_description": {
+          "code": "[%key:component::satel_integra::common::code_input_description%]"
+        }
+      },
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "port": "[%key:common::config_flow::data::port%]"
+        },
+        "data_description": {
+          "host": "[%key:component::satel_integra::config::step::user::data_description::host%]",
+          "port": "[%key:component::satel_integra::config::step::user::data_description::port%]"
+        }
+      },
+      "user": {
         "data": {
-          "code": "[%key:component::satel_integra::common::code%]",
           "host": "[%key:common::config_flow::data::host%]",
           "port": "[%key:common::config_flow::data::port%]"
         },
         "data_description": {
-          "code": "[%key:component::satel_integra::common::code_input_description%]",
           "host": "The IP address of the alarm panel",
           "port": "The port of the alarm panel"
         }

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",