Scrape sub config entry

* power consumption report

* Only keep valid powerConsumptionReports in SmartThings

.github/workflows/builder.yml

@@ -531,7 +531,7 @@ jobs:
 
       - name: Generate artifact attestation
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@bd77c077858b8d561b7a36cbe48ef4cc642ca39d # v2.2.2
+        uses: actions/attest-build-provenance@c074443f1aee8d4aeeae555aebba3282517141b2 # v2.2.3
         with:
           subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
           subject-digest: ${{ steps.push.outputs.digest }}

.github/workflows/ci.yaml

@@ -89,6 +89,7 @@ jobs:
       test_groups: ${{ steps.info.outputs.test_groups }}
       tests_glob: ${{ steps.info.outputs.tests_glob }}
       tests: ${{ steps.info.outputs.tests }}
+      lint_only: ${{ steps.info.outputs.lint_only }}
       skip_coverage: ${{ steps.info.outputs.skip_coverage }}
     runs-on: ubuntu-24.04
     steps:
@@ -142,6 +143,7 @@ jobs:
           test_group_count=10
           tests="[]"
           tests_glob=""
+          lint_only=""
           skip_coverage=""
 
           if [[ "${{ steps.integrations.outputs.changes }}" != "[]" ]];
@@ -192,6 +194,17 @@ jobs:
             test_full_suite="true"
           fi
 
+          if [[ "${{ github.event.inputs.lint-only }}" == "true" ]] \
+            || [[ "${{ github.event.inputs.pylint-only }}" == "true" ]] \
+            || [[ "${{ github.event.inputs.mypy-only }}" == "true" ]] \
+            || [[ "${{ github.event.inputs.audit-licenses-only }}" == "true" ]] \
+            || [[ "${{ github.event_name }}" == "push" \
+              && "${{ github.event.repository.full_name }}" != "home-assistant/core" ]];
+          then
+            lint_only="true"
+            skip_coverage="true"
+          fi
+
           if [[ "${{ github.event.inputs.skip-coverage }}" == "true" ]] \
             || [[ "${{ contains(github.event.pull_request.labels.*.name, 'ci-skip-coverage') }}" == "true" ]];
           then
@@ -217,6 +230,8 @@ jobs:
           echo "tests=${tests}" >> $GITHUB_OUTPUT
           echo "tests_glob: ${tests_glob}"
           echo "tests_glob=${tests_glob}" >> $GITHUB_OUTPUT
+          echo "lint_only": ${lint_only}
+          echo "lint_only=${lint_only}" >> $GITHUB_OUTPUT
           echo "skip_coverage: ${skip_coverage}"
           echo "skip_coverage=${skip_coverage}" >> $GITHUB_OUTPUT
 
@@ -829,11 +844,7 @@ jobs:
   prepare-pytest-full:
     runs-on: ubuntu-24.04
     if: |
-      (github.event_name != 'push' || github.event.repository.full_name == 'home-assistant/core')
-      && github.event.inputs.lint-only != 'true'
-      && github.event.inputs.pylint-only != 'true'
-      && github.event.inputs.mypy-only != 'true'
-      && github.event.inputs.audit-licenses-only != 'true'
+      needs.info.outputs.lint_only != 'true'
       && needs.info.outputs.test_full_suite == 'true'
     needs:
       - info
@@ -886,11 +897,7 @@ jobs:
   pytest-full:
     runs-on: ubuntu-24.04
     if: |
-      (github.event_name != 'push' || github.event.repository.full_name == 'home-assistant/core')
-      && github.event.inputs.lint-only != 'true'
-      && github.event.inputs.pylint-only != 'true'
-      && github.event.inputs.mypy-only != 'true'
-      && github.event.inputs.audit-licenses-only != 'true'
+      needs.info.outputs.lint_only != 'true'
       && needs.info.outputs.test_full_suite == 'true'
     needs:
       - info
@@ -962,6 +969,7 @@ jobs:
           if [[ "${{ needs.info.outputs.skip_coverage }}" != "true" ]]; then
             cov_params+=(--cov="homeassistant")
             cov_params+=(--cov-report=xml)
+            cov_params+=(--junitxml=junit.xml -o junit_family=legacy)
           fi
 
           echo "Test group ${{ matrix.group }}: $(sed -n "${{ matrix.group }},1p" pytest_buckets.txt)"
@@ -992,6 +1000,12 @@ jobs:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml
           overwrite: true
+      - name: Upload test results artifact
+        if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
+        uses: actions/upload-artifact@v4.6.1
+        with:
+          name: test-results-full-${{ matrix.python-version }}-${{ matrix.group }}
+          path: junit.xml
       - name: Remove pytest_buckets
         run: rm pytest_buckets.txt
       - name: Check dirty
@@ -1009,11 +1023,7 @@ jobs:
           MYSQL_ROOT_PASSWORD: password
         options: --health-cmd="mysqladmin ping -uroot -ppassword" --health-interval=5s --health-timeout=2s --health-retries=3
     if: |
-      (github.event_name != 'push' || github.event.repository.full_name == 'home-assistant/core')
-      && github.event.inputs.lint-only != 'true'
-      && github.event.inputs.pylint-only != 'true'
-      && github.event.inputs.mypy-only != 'true'
-      && github.event.inputs.audit-licenses-only != 'true'
+      needs.info.outputs.lint_only != 'true'
       && needs.info.outputs.mariadb_groups != '[]'
     needs:
       - info
@@ -1088,6 +1098,7 @@ jobs:
             cov_params+=(--cov="homeassistant.components.recorder")
             cov_params+=(--cov-report=xml)
             cov_params+=(--cov-report=term-missing)
+            cov_params+=(--junitxml=junit.xml -o junit_family=legacy)
           fi
 
           python3 -b -X dev -m pytest \
@@ -1122,6 +1133,13 @@ jobs:
             steps.pytest-partial.outputs.mariadb }}
           path: coverage.xml
           overwrite: true
+      - name: Upload test results artifact
+        if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
+        uses: actions/upload-artifact@v4.6.1
+        with:
+          name: test-results-mariadb-${{ matrix.python-version }}-${{
+            steps.pytest-partial.outputs.mariadb }}
+          path: junit.xml
       - name: Check dirty
         run: |
           ./script/check_dirty
@@ -1137,11 +1155,7 @@ jobs:
           POSTGRES_PASSWORD: password
         options: --health-cmd="pg_isready -hlocalhost -Upostgres" --health-interval=5s --health-timeout=2s --health-retries=3
     if: |
-      (github.event_name != 'push' || github.event.repository.full_name == 'home-assistant/core')
-      && github.event.inputs.lint-only != 'true'
-      && github.event.inputs.pylint-only != 'true'
-      && github.event.inputs.mypy-only != 'true'
-      && github.event.inputs.audit-licenses-only != 'true'
+      needs.info.outputs.lint_only != 'true'
       && needs.info.outputs.postgresql_groups != '[]'
     needs:
       - info
@@ -1218,6 +1232,7 @@ jobs:
             cov_params+=(--cov="homeassistant.components.recorder")
             cov_params+=(--cov-report=xml)
             cov_params+=(--cov-report=term-missing)
+            cov_params+=(--junitxml=junit.xml -o junit_family=legacy)
           fi
 
           python3 -b -X dev -m pytest \
@@ -1253,6 +1268,13 @@ jobs:
             steps.pytest-partial.outputs.postgresql }}
           path: coverage.xml
           overwrite: true
+      - name: Upload test results artifact
+        if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
+        uses: actions/upload-artifact@v4.6.1
+        with:
+          name: test-results-postgres-${{ matrix.python-version }}-${{
+            steps.pytest-partial.outputs.postgresql }}
+          path: junit.xml
       - name: Check dirty
         run: |
           ./script/check_dirty
@@ -1285,11 +1307,7 @@ jobs:
   pytest-partial:
     runs-on: ubuntu-24.04
     if: |
-      (github.event_name != 'push' || github.event.repository.full_name == 'home-assistant/core')
-      && github.event.inputs.lint-only != 'true'
-      && github.event.inputs.pylint-only != 'true'
-      && github.event.inputs.mypy-only != 'true'
-      && github.event.inputs.audit-licenses-only != 'true'
+      needs.info.outputs.lint_only != 'true'
       && needs.info.outputs.tests_glob
       && needs.info.outputs.test_full_suite == 'false'
     needs:
@@ -1365,6 +1383,7 @@ jobs:
             cov_params+=(--cov="homeassistant.components.${{ matrix.group }}")
             cov_params+=(--cov-report=xml)
             cov_params+=(--cov-report=term-missing)
+            cov_params+=(--junitxml=junit.xml -o junit_family=legacy)
           fi
 
           python3 -b -X dev -m pytest \
@@ -1394,6 +1413,12 @@ jobs:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml
           overwrite: true
+      - name: Upload test results artifact
+        if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
+        uses: actions/upload-artifact@v4.6.1
+        with:
+          name: test-results-partial-${{ matrix.python-version }}-${{ matrix.group }}
+          path: junit.xml
       - name: Check dirty
         run: |
           ./script/check_dirty
@@ -1419,3 +1444,28 @@ jobs:
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}
+
+  upload-test-results:
+    name: Upload test results to Codecov
+    # codecov/test-results-action currently doesn't support tokenless uploads
+    # therefore we can't run it on forks
+    if: ${{ (github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork) && needs.info.outputs.skip_coverage != 'true' && !cancelled() }}
+    runs-on: ubuntu-24.04
+    needs:
+      - info
+      - pytest-partial
+      - pytest-full
+      - pytest-postgres
+      - pytest-mariadb
+    timeout-minutes: 10
+    steps:
+      - name: Download all coverage artifacts
+        uses: actions/download-artifact@v4.1.9
+        with:
+          pattern: test-results-*
+      - name: Upload test results to Codecov
+        uses: codecov/test-results-action@v1
+        with:
+          fail_ci_if_error: true
+          verbose: true
+          token: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -69,6 +69,7 @@ test-reports/
 test-results.xml
 test-output.xml
 pytest-*.txt
+junit.xml
 
 # Translations
 *.mo

.strict-typing

@@ -136,6 +136,7 @@ homeassistant.components.clicksend.*
 homeassistant.components.climate.*
 homeassistant.components.cloud.*
 homeassistant.components.co2signal.*
+homeassistant.components.comelit.*
 homeassistant.components.command_line.*
 homeassistant.components.config.*
 homeassistant.components.configurator.*

CODEOWNERS

@@ -1529,8 +1529,8 @@ build.json @home-assistant/supervisor
 /tests/components/tedee/ @patrickhilker @zweckj
 /homeassistant/components/tellduslive/ @fredrike
 /tests/components/tellduslive/ @fredrike
-/homeassistant/components/template/ @PhracturedBlue @home-assistant/core
-/tests/components/template/ @PhracturedBlue @home-assistant/core
+/homeassistant/components/template/ @Petro31 @PhracturedBlue @home-assistant/core
+/tests/components/template/ @Petro31 @PhracturedBlue @home-assistant/core
 /homeassistant/components/tesla_fleet/ @Bre77
 /tests/components/tesla_fleet/ @Bre77
 /homeassistant/components/tesla_wall_connector/ @einarhauks

homeassistant/bootstrap.py

@@ -81,6 +81,7 @@ from .helpers import (
     entity,
     entity_registry,
     floor_registry,
+    frame,
     issue_registry,
     label_registry,
     recorder,
@@ -441,9 +442,10 @@ async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
     if DATA_REGISTRIES_LOADED in hass.data:
         return
     hass.data[DATA_REGISTRIES_LOADED] = None
-    translation.async_setup(hass)
     entity.async_setup(hass)
+    frame.async_setup(hass)
     template.async_setup(hass)
+    translation.async_setup(hass)
     await asyncio.gather(
         create_eager_task(get_internal_store_manager(hass).async_initialize()),
         create_eager_task(area_registry.async_load(hass)),
@@ -664,11 +666,10 @@ def _create_log_file(
         err_handler = _RotatingFileHandlerWithoutShouldRollOver(
             err_log_path, backupCount=1
         )
-
-    try:
-        err_handler.doRollover()
-    except OSError as err:
-        _LOGGER.error("Error rolling over log file: %s", err)
+        try:
+            err_handler.doRollover()
+        except OSError as err:
+            _LOGGER.error("Error rolling over log file: %s", err)
 
     return err_handler
 

homeassistant/components/advantage_air/climate.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from decimal import Decimal
 import logging
 from typing import Any
 
@@ -14,6 +15,7 @@ from homeassistant.components.climate import (
     FAN_MEDIUM,
     ClimateEntity,
     ClimateEntityFeature,
+    HVACAction,
     HVACMode,
 )
 from homeassistant.const import ATTR_TEMPERATURE, PRECISION_WHOLE, UnitOfTemperature
@@ -49,6 +51,14 @@ ADVANTAGE_AIR_MYTEMP_ENABLED = "climateControlModeEnabled"
 ADVANTAGE_AIR_HEAT_TARGET = "myAutoHeatTargetTemp"
 ADVANTAGE_AIR_COOL_TARGET = "myAutoCoolTargetTemp"
 ADVANTAGE_AIR_MYFAN = "autoAA"
+ADVANTAGE_AIR_MYAUTO_MODE_SET = "myAutoModeCurrentSetMode"
+
+HVAC_ACTIONS = {
+    "cool": HVACAction.COOLING,
+    "heat": HVACAction.HEATING,
+    "vent": HVACAction.FAN,
+    "dry": HVACAction.DRYING,
+}
 
 HVAC_MODES = [
     HVACMode.OFF,
@@ -175,6 +185,17 @@ class AdvantageAirAC(AdvantageAirAcEntity, ClimateEntity):
             return ADVANTAGE_AIR_HVAC_MODES.get(self._ac["mode"])
         return HVACMode.OFF
 
+    @property
+    def hvac_action(self) -> HVACAction | None:
+        """Return the current running HVAC action."""
+        if self._ac["state"] == ADVANTAGE_AIR_STATE_OFF:
+            return HVACAction.OFF
+        if self._ac["mode"] == "myauto":
+            return HVAC_ACTIONS.get(
+                self._ac.get(ADVANTAGE_AIR_MYAUTO_MODE_SET, HVACAction.OFF)
+            )
+        return HVAC_ACTIONS.get(self._ac["mode"])
+
     @property
     def fan_mode(self) -> str | None:
         """Return the current fan modes."""
@@ -273,6 +294,22 @@ class AdvantageAirZone(AdvantageAirZoneEntity, ClimateEntity):
             return HVACMode.HEAT_COOL
         return HVACMode.OFF
 
+    @property
+    def hvac_action(self) -> HVACAction | None:
+        """Return the HVAC action, inheriting from master AC if zone is open but idle if air is <= 5%."""
+        if self._ac["state"] == ADVANTAGE_AIR_STATE_OFF:
+            return HVACAction.OFF
+        master_action = HVAC_ACTIONS.get(self._ac["mode"], HVACAction.OFF)
+        if self._ac["mode"] == "myauto":
+            master_action = HVAC_ACTIONS.get(
+                str(self._ac.get(ADVANTAGE_AIR_MYAUTO_MODE_SET)), HVACAction.OFF
+            )
+        if self._zone["state"] == ADVANTAGE_AIR_STATE_OPEN:
+            if self._zone["value"] <= Decimal(5):
+                return HVACAction.IDLE
+            return master_action
+        return HVACAction.OFF
+
     @property
     def current_temperature(self) -> float | None:
         """Return the current temperature."""

homeassistant/components/advantage_air/const.py

@@ -7,3 +7,4 @@ ADVANTAGE_AIR_STATE_CLOSE = "close"
 ADVANTAGE_AIR_STATE_ON = "on"
 ADVANTAGE_AIR_STATE_OFF = "off"
 ADVANTAGE_AIR_AUTOFAN_ENABLED = "aaAutoFanModeEnabled"
+ADVANTAGE_AIR_NIGHT_MODE_ENABLED = "quietNightModeEnabled"

homeassistant/components/advantage_air/cover.py

@@ -41,7 +41,7 @@ async def async_setup_entry(
                 entities.append(
                     AdvantageAirThingCover(instance, thing, CoverDeviceClass.BLIND)
                 )
-            elif thing["channelDipState"] == 3:  # 3 = "Garage door"
+            elif thing["channelDipState"] in [3, 10]:  # 3 & 10 = "Garage door"
                 entities.append(
                     AdvantageAirThingCover(instance, thing, CoverDeviceClass.GARAGE)
                 )

homeassistant/components/advantage_air/switch.py

@@ -9,6 +9,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import AdvantageAirDataConfigEntry
 from .const import (
     ADVANTAGE_AIR_AUTOFAN_ENABLED,
+    ADVANTAGE_AIR_NIGHT_MODE_ENABLED,
     ADVANTAGE_AIR_STATE_OFF,
     ADVANTAGE_AIR_STATE_ON,
 )
@@ -32,6 +33,8 @@ async def async_setup_entry(
                 entities.append(AdvantageAirFreshAir(instance, ac_key))
             if ADVANTAGE_AIR_AUTOFAN_ENABLED in ac_device["info"]:
                 entities.append(AdvantageAirMyFan(instance, ac_key))
+            if ADVANTAGE_AIR_NIGHT_MODE_ENABLED in ac_device["info"]:
+                entities.append(AdvantageAirNightMode(instance, ac_key))
     if things := instance.coordinator.data.get("myThings"):
         entities.extend(
             AdvantageAirRelay(instance, thing)
@@ -93,6 +96,32 @@ class AdvantageAirMyFan(AdvantageAirAcEntity, SwitchEntity):
         await self.async_update_ac({ADVANTAGE_AIR_AUTOFAN_ENABLED: False})
 
 
+class AdvantageAirNightMode(AdvantageAirAcEntity, SwitchEntity):
+    """Representation of Advantage 'MySleep$aver' Mode control."""
+
+    _attr_icon = "mdi:weather-night"
+    _attr_name = "MySleep$aver"
+    _attr_device_class = SwitchDeviceClass.SWITCH
+
+    def __init__(self, instance: AdvantageAirData, ac_key: str) -> None:
+        """Initialize an Advantage Air Night Mode control."""
+        super().__init__(instance, ac_key)
+        self._attr_unique_id += "-nightmode"
+
+    @property
+    def is_on(self) -> bool:
+        """Return the Night Mode status."""
+        return self._ac[ADVANTAGE_AIR_NIGHT_MODE_ENABLED]
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn Night Mode on."""
+        await self.async_update_ac({ADVANTAGE_AIR_NIGHT_MODE_ENABLED: True})
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn Night Mode off."""
+        await self.async_update_ac({ADVANTAGE_AIR_NIGHT_MODE_ENABLED: False})
+
+
 class AdvantageAirRelay(AdvantageAirThingEntity, SwitchEntity):
     """Representation of Advantage Air Thing."""
 

homeassistant/components/analytics_insights/config_flow.py

@@ -8,7 +8,7 @@ from python_homeassistant_analytics import (
     HomeassistantAnalyticsClient,
     HomeassistantAnalyticsConnectionError,
 )
-from python_homeassistant_analytics.models import IntegrationType
+from python_homeassistant_analytics.models import Environment, IntegrationType
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
@@ -81,7 +81,7 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
         )
         try:
             addons = await client.get_addons()
-            integrations = await client.get_integrations()
+            integrations = await client.get_integrations(Environment.NEXT)
             custom_integrations = await client.get_custom_integrations()
         except HomeassistantAnalyticsConnectionError:
             LOGGER.exception("Error connecting to Home Assistant analytics")
@@ -165,7 +165,7 @@ class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlow):
         )
         try:
             addons = await client.get_addons()
-            integrations = await client.get_integrations()
+            integrations = await client.get_integrations(Environment.NEXT)
             custom_integrations = await client.get_custom_integrations()
         except HomeassistantAnalyticsConnectionError:
             LOGGER.exception("Error connecting to Home Assistant analytics")

homeassistant/components/anthropic/conversation.py

@@ -305,7 +305,9 @@ class AnthropicConversationEntity(
         intent_response = intent.IntentResponse(language=user_input.language)
         intent_response.async_set_speech(response_content.content or "")
         return conversation.ConversationResult(
-            response=intent_response, conversation_id=chat_log.conversation_id
+            response=intent_response,
+            conversation_id=chat_log.conversation_id,
+            continue_conversation=chat_log.continue_conversation,
         )
 
     async def _async_entry_update_listener(

homeassistant/components/apollo_automation/__init__.py

@@ -0,0 +1 @@
+"""Virtual integration: Apollo Automation."""

homeassistant/components/apollo_automation/manifest.json

@@ -0,0 +1,6 @@
+{
+  "domain": "apollo_automation",
+  "name": "Apollo Automation",
+  "integration_type": "virtual",
+  "supported_by": "esphome"
+}

homeassistant/components/assist_pipeline/pipeline.py

@@ -20,6 +20,9 @@ import hass_nabucasa
 import voluptuous as vol
 
 from homeassistant.components import conversation, stt, tts, wake_word, websocket_api
+from homeassistant.components.tts import (
+    generate_media_source_id as tts_generate_media_source_id,
+)
 from homeassistant.const import ATTR_SUPPORTED_FEATURES, MATCH_ALL
 from homeassistant.core import Context, HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
@@ -1272,10 +1275,26 @@ class PipelineRun:
             )
         )
 
+        try:
+            # Synthesize audio and get URL
+            tts_media_id = tts_generate_media_source_id(
+                self.hass,
+                tts_input,
+                engine=self.tts_stream.engine,
+                language=self.tts_stream.language,
+                options=self.tts_stream.options,
+            )
+        except Exception as src_error:
+            _LOGGER.exception("Unexpected error during text-to-speech")
+            raise TextToSpeechError(
+                code="tts-failed",
+                message="Unexpected error during text-to-speech",
+            ) from src_error
+
         self.tts_stream.async_set_message(tts_input)
 
         tts_output = {
-            "media_id": self.tts_stream.media_source_id,
+            "media_id": tts_media_id,
             "url": self.tts_stream.url,
             "mime_type": self.tts_stream.content_type,
         }

homeassistant/components/assist_satellite/entity.py

@@ -23,6 +23,9 @@ from homeassistant.components.assist_pipeline import (
     vad,
 )
 from homeassistant.components.media_player import async_process_play_media_url
+from homeassistant.components.tts import (
+    generate_media_source_id as tts_generate_media_source_id,
+)
 from homeassistant.core import Context, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import chat_session, entity
@@ -481,9 +484,6 @@ class AssistSatelliteEntity(entity.Entity):
             pipeline_id = self._resolve_pipeline()
             pipeline = async_get_pipeline(self.hass, pipeline_id)
 
-            if pipeline.tts_engine is None:
-                raise HomeAssistantError("Pipeline has no TTS engine configured")
-
             tts_options: dict[str, Any] = {}
             if pipeline.tts_voice is not None:
                 tts_options[tts.ATTR_VOICE] = pipeline.tts_voice
@@ -491,15 +491,14 @@ class AssistSatelliteEntity(entity.Entity):
             if self.tts_options is not None:
                 tts_options.update(self.tts_options)
 
-            stream = tts.async_create_stream(
+            media_id = tts_generate_media_source_id(
                 self.hass,
+                message,
                 engine=pipeline.tts_engine,
                 language=pipeline.tts_language,
                 options=tts_options,
             )
-            stream.async_set_message(message)
-            media_id = stream.url
-            original_media_id = stream.media_source_id
+            original_media_id = media_id
 
         if media_source.is_media_source_id(media_id):
             if not media_id_source:

homeassistant/components/azure_storage/backup.py

@@ -141,7 +141,7 @@ class AzureStorageBackupAgent(BackupAgent):
         """Delete a backup file."""
         blob = await self._find_blob_by_backup_id(backup_id)
         if blob is None:
-            return
+            raise BackupNotFound(f"Backup {backup_id} not found")
         await self._client.delete_blob(blob.name)
 
     @handle_backup_errors
@@ -163,11 +163,11 @@ class AzureStorageBackupAgent(BackupAgent):
         self,
         backup_id: str,
         **kwargs: Any,
-    ) -> AgentBackup | None:
+    ) -> AgentBackup:
         """Return a backup."""
         blob = await self._find_blob_by_backup_id(backup_id)
         if blob is None:
-            return None
+            raise BackupNotFound(f"Backup {backup_id} not found")
 
         return AgentBackup.from_dict(json.loads(blob.metadata["backup_metadata"]))
 

homeassistant/components/backup/agent.py

@@ -41,6 +41,8 @@ class BackupAgent(abc.ABC):
     ) -> AsyncIterator[bytes]:
         """Download a backup file.
 
+        Raises BackupNotFound if the backup does not exist.
+
         :param backup_id: The ID of the backup that was returned in async_list_backups.
         :return: An async iterator that yields bytes.
         """
@@ -67,6 +69,8 @@ class BackupAgent(abc.ABC):
     ) -> None:
         """Delete a backup file.
 
+        Raises BackupNotFound if the backup does not exist.
+
         :param backup_id: The ID of the backup that was returned in async_list_backups.
         """
 
@@ -79,8 +83,11 @@ class BackupAgent(abc.ABC):
         self,
         backup_id: str,
         **kwargs: Any,
-    ) -> AgentBackup | None:
-        """Return a backup."""
+    ) -> AgentBackup:
+        """Return a backup.
+
+        Raises BackupNotFound if the backup does not exist.
+        """
 
 
 class LocalBackupAgent(BackupAgent):

homeassistant/components/backup/backup.py

@@ -88,13 +88,13 @@ class CoreLocalBackupAgent(LocalBackupAgent):
         self,
         backup_id: str,
         **kwargs: Any,
-    ) -> AgentBackup | None:
+    ) -> AgentBackup:
         """Return a backup."""
         if not self._loaded_backups:
             await self._load_backups()
 
         if backup_id not in self._backups:
-            return None
+            raise BackupNotFound(f"Backup {backup_id} not found")
 
         backup, backup_path = self._backups[backup_id]
         if not await self._hass.async_add_executor_job(backup_path.exists):
@@ -107,7 +107,7 @@ class CoreLocalBackupAgent(LocalBackupAgent):
                 backup_path,
             )
             self._backups.pop(backup_id)
-            return None
+            raise BackupNotFound(f"Backup {backup_id} not found")
 
         return backup
 
@@ -130,10 +130,7 @@ class CoreLocalBackupAgent(LocalBackupAgent):
         if not self._loaded_backups:
             await self._load_backups()
 
-        try:
-            backup_path = self.get_backup_path(backup_id)
-        except BackupNotFound:
-            return
+        backup_path = self.get_backup_path(backup_id)
         await self._hass.async_add_executor_job(backup_path.unlink, True)
         LOGGER.debug("Deleted backup located at %s", backup_path)
         self._backups.pop(backup_id)

homeassistant/components/backup/http.py

@@ -15,6 +15,7 @@ from multidict import istr
 from homeassistant.components.http import KEY_HASS, HomeAssistantView, require_admin
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import frame
 from homeassistant.util import slugify
 
 from . import util
@@ -59,11 +60,19 @@ class DownloadBackupView(HomeAssistantView):
         if agent_id not in manager.backup_agents:
             return Response(status=HTTPStatus.BAD_REQUEST)
         agent = manager.backup_agents[agent_id]
-        backup = await agent.async_get_backup(backup_id)
+        try:
+            backup = await agent.async_get_backup(backup_id)
+        except BackupNotFound:
+            return Response(status=HTTPStatus.NOT_FOUND)
 
-        # We don't need to check if the path exists, aiohttp.FileResponse will handle
-        # that
-        if backup is None:
+        # Check for None to be backwards compatible with the old BackupAgent API,
+        # this can be removed in HA Core 2025.10
+        if not backup:
+            frame.report_usage(
+                "returns None from BackupAgent.async_get_backup",
+                breaks_in_ha_version="2025.10",
+                integration_domain=agent_id.partition(".")[0],
+            )
             return Response(status=HTTPStatus.NOT_FOUND)
 
         headers = {
@@ -92,6 +101,8 @@ class DownloadBackupView(HomeAssistantView):
     ) -> StreamResponse | FileResponse | Response:
         if agent_id in manager.local_backup_agents:
             local_agent = manager.local_backup_agents[agent_id]
+            # We don't need to check if the path exists, aiohttp.FileResponse will
+            # handle that
             path = local_agent.get_backup_path(backup_id)
             return FileResponse(path=path.as_posix(), headers=headers)
 

homeassistant/components/backup/manager.py

@@ -30,6 +30,7 @@ from homeassistant.backup_restore import (
 from homeassistant.const import __version__ as HAVERSION
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import (
+    frame,
     instance_id,
     integration_platform,
     issue_registry as ir,
@@ -64,6 +65,7 @@ from .models import (
     AgentBackup,
     BackupError,
     BackupManagerError,
+    BackupNotFound,
     BackupReaderWriterError,
     BaseBackup,
     Folder,
@@ -648,6 +650,8 @@ class BackupManager:
         )
         for idx, result in enumerate(get_backup_results):
             agent_id = agent_ids[idx]
+            if isinstance(result, BackupNotFound):
+                continue
             if isinstance(result, BackupAgentError):
                 agent_errors[agent_id] = result
                 continue
@@ -659,7 +663,14 @@ class BackupManager:
                 continue
             if isinstance(result, BaseException):
                 raise result  # unexpected error
+            # Check for None to be backwards compatible with the old BackupAgent API,
+            # this can be removed in HA Core 2025.10
             if not result:
+                frame.report_usage(
+                    "returns None from BackupAgent.async_get_backup",
+                    breaks_in_ha_version="2025.10",
+                    integration_domain=agent_id.partition(".")[0],
+                )
                 continue
             if backup is None:
                 if known_backup := self.known_backups.get(backup_id):
@@ -723,6 +734,8 @@ class BackupManager:
         )
         for idx, result in enumerate(delete_backup_results):
             agent_id = agent_ids[idx]
+            if isinstance(result, BackupNotFound):
+                continue
             if isinstance(result, BackupAgentError):
                 agent_errors[agent_id] = result
                 continue
@@ -832,7 +845,7 @@ class BackupManager:
         agent_errors = {
             backup_id: error
             for backup_id, error in zip(backup_ids, delete_results, strict=True)
-            if error
+            if error and not isinstance(error, BackupNotFound)
         }
         if agent_errors:
             LOGGER.error(
@@ -1264,7 +1277,20 @@ class BackupManager:
     ) -> None:
         """Initiate restoring a backup."""
         agent = self.backup_agents[agent_id]
-        if not await agent.async_get_backup(backup_id):
+        try:
+            backup = await agent.async_get_backup(backup_id)
+        except BackupNotFound as err:
+            raise BackupManagerError(
+                f"Backup {backup_id} not found in agent {agent_id}"
+            ) from err
+        # Check for None to be backwards compatible with the old BackupAgent API,
+        # this can be removed in HA Core 2025.10
+        if not backup:
+            frame.report_usage(
+                "returns None from BackupAgent.async_get_backup",
+                breaks_in_ha_version="2025.10",
+                integration_domain=agent_id.partition(".")[0],
+            )
             raise BackupManagerError(
                 f"Backup {backup_id} not found in agent {agent_id}"
             )
@@ -1352,7 +1378,20 @@ class BackupManager:
             agent = self.backup_agents[agent_id]
         except KeyError as err:
             raise BackupManagerError(f"Invalid agent selected: {agent_id}") from err
-        if not await agent.async_get_backup(backup_id):
+        try:
+            backup = await agent.async_get_backup(backup_id)
+        except BackupNotFound as err:
+            raise BackupManagerError(
+                f"Backup {backup_id} not found in agent {agent_id}"
+            ) from err
+        # Check for None to be backwards compatible with the old BackupAgent API,
+        # this can be removed in HA Core 2025.10
+        if not backup:
+            frame.report_usage(
+                "returns None from BackupAgent.async_get_backup",
+                breaks_in_ha_version="2025.10",
+                integration_domain=agent_id.partition(".")[0],
+            )
             raise BackupManagerError(
                 f"Backup {backup_id} not found in agent {agent_id}"
             )

homeassistant/components/balboa/__init__.py

@@ -21,6 +21,7 @@ _LOGGER = logging.getLogger(__name__)
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.CLIMATE,
+    Platform.EVENT,
     Platform.FAN,
     Platform.LIGHT,
     Platform.SELECT,
@@ -28,7 +29,6 @@ PLATFORMS = [
     Platform.TIME,
 ]
 
-
 KEEP_ALIVE_INTERVAL = timedelta(minutes=1)
 SYNC_TIME_INTERVAL = timedelta(hours=1)
 

homeassistant/components/balboa/event.py

@@ -0,0 +1,91 @@
+"""Support for Balboa events."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+from pybalboa import EVENT_UPDATE, SpaClient
+
+from homeassistant.components.event import EventEntity
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.event import async_track_time_interval
+
+from . import BalboaConfigEntry
+from .entity import BalboaEntity
+
+FAULT = "fault"
+FAULT_DATE = "fault_date"
+REQUEST_FAULT_LOG_INTERVAL = timedelta(minutes=5)
+
+FAULT_MESSAGE_CODE_MAP: dict[int, str] = {
+    15: "sensor_out_of_sync",
+    16: "low_flow",
+    17: "flow_failed",
+    18: "settings_reset",
+    19: "priming_mode",
+    20: "clock_failed",
+    21: "settings_reset",
+    22: "memory_failure",
+    26: "service_sensor_sync",
+    27: "heater_dry",
+    28: "heater_may_be_dry",
+    29: "water_too_hot",
+    30: "heater_too_hot",
+    31: "sensor_a_fault",
+    32: "sensor_b_fault",
+    34: "pump_stuck",
+    35: "hot_fault",
+    36: "gfci_test_failed",
+    37: "standby_mode",
+}
+FAULT_EVENT_TYPES = sorted(set(FAULT_MESSAGE_CODE_MAP.values()))
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: BalboaConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the spa's events."""
+    async_add_entities([BalboaEventEntity(entry.runtime_data)])
+
+
+class BalboaEventEntity(BalboaEntity, EventEntity):
+    """Representation of a Balboa event entity."""
+
+    _attr_event_types = FAULT_EVENT_TYPES
+    _attr_translation_key = FAULT
+
+    def __init__(self, spa: SpaClient) -> None:
+        """Initialize a Balboa event entity."""
+        super().__init__(spa, FAULT)
+
+    @callback
+    def _async_handle_event(self) -> None:
+        """Handle the fault event."""
+        if not (fault := self._client.fault):
+            return
+        fault_date = fault.fault_datetime.isoformat()
+        if self.state_attributes.get(FAULT_DATE) != fault_date:
+            self._trigger_event(
+                FAULT_MESSAGE_CODE_MAP.get(fault.message_code, fault.message),
+                {FAULT_DATE: fault_date, "code": fault.message_code},
+            )
+            self.async_write_ha_state()
+
+    async def async_added_to_hass(self) -> None:
+        """Run when entity about to be added to hass."""
+        await super().async_added_to_hass()
+        self.async_on_remove(self._client.on(EVENT_UPDATE, self._async_handle_event))
+
+        async def request_fault_log(now: datetime | None = None) -> None:
+            """Request the most recent fault log."""
+            await self._client.request_fault_log()
+
+        await request_fault_log()
+        self.async_on_remove(
+            async_track_time_interval(
+                self.hass, request_fault_log, REQUEST_FAULT_LOG_INTERVAL
+            )
+        )

homeassistant/components/balboa/strings.json

@@ -57,6 +57,35 @@
         }
       }
     },
+    "event": {
+      "fault": {
+        "name": "Fault",
+        "state_attributes": {
+          "event_type": {
+            "state": {
+              "sensor_out_of_sync": "Sensors are out of sync",
+              "low_flow": "The water flow is low",
+              "flow_failed": "The water flow has failed",
+              "settings_reset": "The settings have been reset",
+              "priming_mode": "Priming mode",
+              "clock_failed": "The clock has failed",
+              "memory_failure": "Program memory failure",
+              "service_sensor_sync": "Sensors are out of sync -- call for service",
+              "heater_dry": "The heater is dry",
+              "heater_may_be_dry": "The heater may be dry",
+              "water_too_hot": "The water is too hot",
+              "heater_too_hot": "The heater is too hot",
+              "sensor_a_fault": "Sensor A fault",
+              "sensor_b_fault": "Sensor B fault",
+              "pump_stuck": "A pump may be stuck on",
+              "hot_fault": "Hot fault",
+              "gfci_test_failed": "The GFCI test failed",
+              "standby_mode": "Standby mode (hold mode)"
+            }
+          }
+        }
+      }
+    },
     "fan": {
       "pump": {
         "name": "Pump {index}"

homeassistant/components/bluetooth/manifest.json

@@ -19,8 +19,8 @@
     "bleak-retry-connector==3.9.0",
     "bluetooth-adapters==0.21.4",
     "bluetooth-auto-recovery==1.4.4",
-    "bluetooth-data-tools==1.23.4",
-    "dbus-fast==2.33.0",
-    "habluetooth==3.24.1"
+    "bluetooth-data-tools==1.25.0",
+    "dbus-fast==2.39.3",
+    "habluetooth==3.25.0"
   ]
 }

homeassistant/components/calendar/__init__.py

@@ -153,6 +153,27 @@ def _has_min_duration(
     return validate
 
 
+def _has_positive_interval(
+    start_key: str, end_key: str, duration_key: str
+) -> Callable[[dict[str, Any]], dict[str, Any]]:
+    """Verify that the time span between start and end is greater than zero."""
+
+    def validate(obj: dict[str, Any]) -> dict[str, Any]:
+        if (duration := obj.get(duration_key)) is not None:
+            if duration <= datetime.timedelta(seconds=0):
+                raise vol.Invalid(f"Expected positive duration ({duration})")
+            return obj
+
+        if (start := obj.get(start_key)) and (end := obj.get(end_key)):
+            if start >= end:
+                raise vol.Invalid(
+                    f"Expected end time to be after start time ({start}, {end})"
+                )
+        return obj
+
+    return validate
+
+
 def _has_same_type(*keys: Any) -> Callable[[dict[str, Any]], dict[str, Any]]:
     """Verify that all values are of the same type."""
 
@@ -281,6 +302,7 @@ SERVICE_GET_EVENTS_SCHEMA: Final = vol.All(
             ),
         }
     ),
+    _has_positive_interval(EVENT_START_DATETIME, EVENT_END_DATETIME, EVENT_DURATION),
 )
 
 
@@ -870,6 +892,7 @@ async def async_get_events_service(
         end = start + service_call.data[EVENT_DURATION]
     else:
         end = service_call.data[EVENT_END_DATETIME]
+
     calendar_event_list = await calendar.async_get_events(
         calendar.hass, dt_util.as_local(start), dt_util.as_local(end)
     )

homeassistant/components/cloud/backup.py

@@ -18,7 +18,12 @@ from hass_nabucasa.cloud_api import (
 )
 from hass_nabucasa.files import FilesError, StorageType, calculate_b64md5
 
-from homeassistant.components.backup import AgentBackup, BackupAgent, BackupAgentError
+from homeassistant.components.backup import (
+    AgentBackup,
+    BackupAgent,
+    BackupAgentError,
+    BackupNotFound,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import ChunkAsyncStreamIterator
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -90,9 +95,7 @@ class CloudBackupAgent(BackupAgent):
         :param backup_id: The ID of the backup that was returned in async_list_backups.
         :return: An async iterator that yields bytes.
         """
-        if not (backup := await self._async_get_backup(backup_id)):
-            raise BackupAgentError("Backup not found")
-
+        backup = await self._async_get_backup(backup_id)
         try:
             content = await self._cloud.files.download(
                 storage_type=StorageType.BACKUP,
@@ -171,9 +174,7 @@ class CloudBackupAgent(BackupAgent):
 
         :param backup_id: The ID of the backup that was returned in async_list_backups.
         """
-        if not (backup := await self._async_get_backup(backup_id)):
-            return
-
+        backup = await self._async_get_backup(backup_id)
         try:
             await async_files_delete_file(
                 self._cloud,
@@ -204,16 +205,12 @@ class CloudBackupAgent(BackupAgent):
         self,
         backup_id: str,
         **kwargs: Any,
-    ) -> AgentBackup | None:
+    ) -> AgentBackup:
         """Return a backup."""
-        if not (backup := await self._async_get_backup(backup_id)):
-            return None
+        backup = await self._async_get_backup(backup_id)
         return AgentBackup.from_dict(backup["Metadata"])
 
-    async def _async_get_backup(
-        self,
-        backup_id: str,
-    ) -> FilesHandlerListEntry | None:
+    async def _async_get_backup(self, backup_id: str) -> FilesHandlerListEntry:
         """Return a backup."""
         backups = await self._async_list_backups()
 
@@ -221,4 +218,4 @@ class CloudBackupAgent(BackupAgent):
             if backup["Metadata"]["backup_id"] == backup_id:
                 return backup
 
-        return None
+        raise BackupNotFound(f"Backup {backup_id} not found")

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==0.92.0"],
+  "requirements": ["hass-nabucasa==0.94.0"],
   "single_config_entry": true
 }

homeassistant/components/comelit/alarm_control_panel.py

@@ -6,7 +6,7 @@ import logging
 from typing import cast
 
 from aiocomelit.api import ComelitVedoAreaObject
-from aiocomelit.const import ALARM_AREAS, AlarmAreaState
+from aiocomelit.const import AlarmAreaState
 
 from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelEntity,
@@ -56,7 +56,7 @@ async def async_setup_entry(
 
     async_add_entities(
         ComelitAlarmEntity(coordinator, device, config_entry.entry_id)
-        for device in coordinator.data[ALARM_AREAS].values()
+        for device in coordinator.data["alarm_areas"].values()
     )
 
 
@@ -92,7 +92,7 @@ class ComelitAlarmEntity(CoordinatorEntity[ComelitVedoSystem], AlarmControlPanel
     @property
     def _area(self) -> ComelitVedoAreaObject:
         """Return area object."""
-        return self.coordinator.data[ALARM_AREAS][self._area_index]
+        return self.coordinator.data["alarm_areas"][self._area_index]
 
     @property
     def available(self) -> bool:

homeassistant/components/comelit/binary_sensor.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from typing import cast
 
 from aiocomelit import ComelitVedoZoneObject
-from aiocomelit.const import ALARM_ZONES
 
 from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
@@ -29,7 +28,7 @@ async def async_setup_entry(
 
     async_add_entities(
         ComelitVedoBinarySensorEntity(coordinator, device, config_entry.entry_id)
-        for device in coordinator.data[ALARM_ZONES].values()
+        for device in coordinator.data["alarm_zones"].values()
     )
 
 
@@ -49,7 +48,7 @@ class ComelitVedoBinarySensorEntity(
     ) -> None:
         """Init sensor entity."""
         self._api = coordinator.api
-        self._zone = zone
+        self._zone_index = zone.index
         super().__init__(coordinator)
         # Use config_entry.entry_id as base for unique_id
         # because no serial number or mac is available
@@ -59,4 +58,6 @@ class ComelitVedoBinarySensorEntity(
     @property
     def is_on(self) -> bool:
         """Presence detected."""
-        return self.coordinator.data[ALARM_ZONES][self._zone.index].status_api == "0001"
+        return (
+            self.coordinator.data["alarm_zones"][self._zone_index].status_api == "0001"
+        )

homeassistant/components/comelit/climate.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from enum import StrEnum
-from typing import Any, cast
+from typing import Any, TypedDict, cast
 
 from aiocomelit import ComelitSerialBridgeObject
 from aiocomelit.const import CLIMATE
@@ -16,7 +16,8 @@ from homeassistant.components.climate import (
     UnitOfTemperature,
 )
 from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -42,22 +43,23 @@ class ClimaComelitCommand(StrEnum):
     AUTO = "auto"
 
 
-API_STATUS: dict[str, dict[str, Any]] = {
-    ClimaComelitMode.OFF: {
-        "action": "off",
-        "hvac_mode": HVACMode.OFF,
-        "hvac_action": HVACAction.OFF,
-    },
-    ClimaComelitMode.LOWER: {
-        "action": "lower",
-        "hvac_mode": HVACMode.COOL,
-        "hvac_action": HVACAction.COOLING,
-    },
-    ClimaComelitMode.UPPER: {
-        "action": "upper",
-        "hvac_mode": HVACMode.HEAT,
-        "hvac_action": HVACAction.HEATING,
-    },
+class ClimaComelitApiStatus(TypedDict):
+    """Comelit Clima API status."""
+
+    hvac_mode: HVACMode
+    hvac_action: HVACAction
+
+
+API_STATUS: dict[str, ClimaComelitApiStatus] = {
+    ClimaComelitMode.OFF: ClimaComelitApiStatus(
+        hvac_mode=HVACMode.OFF, hvac_action=HVACAction.OFF
+    ),
+    ClimaComelitMode.LOWER: ClimaComelitApiStatus(
+        hvac_mode=HVACMode.COOL, hvac_action=HVACAction.COOLING
+    ),
+    ClimaComelitMode.UPPER: ClimaComelitApiStatus(
+        hvac_mode=HVACMode.HEAT, hvac_action=HVACAction.HEATING
+    ),
 }
 
 MODE_TO_ACTION: dict[HVACMode, ClimaComelitCommand] = {
@@ -114,69 +116,41 @@ class ComelitClimateEntity(CoordinatorEntity[ComelitSerialBridge], ClimateEntity
         self._attr_unique_id = f"{config_entry_entry_id}-{device.index}"
         self._attr_device_info = coordinator.platform_device_info(device, device.type)
 
-    @property
-    def _clima(self) -> list[Any]:
-        """Return clima device data."""
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        device = self.coordinator.data[CLIMATE][self._device.index]
+        if not isinstance(device.val, list):
+            raise HomeAssistantError("Invalid clima data")
+
         # CLIMATE has a 2 item tuple:
         # - first  for Clima
         # - second for Humidifier
-        return self.coordinator.data[CLIMATE][self._device.index].val[0]
+        values = device.val[0]
 
-    @property
-    def _api_mode(self) -> str:
-        """Return device mode."""
-        # Values from API: "O", "L", "U"
-        return self._clima[2]
+        _active = values[1]
+        _mode = values[2]  # Values from API: "O", "L", "U"
+        _automatic = values[3] == ClimaComelitMode.AUTO
 
-    @property
-    def _api_active(self) -> bool:
-        "Return device active/idle."
-        return self._clima[1]
+        self._attr_current_temperature = values[0] / 10
 
-    @property
-    def _api_automatic(self) -> bool:
-        """Return device in automatic/manual mode."""
-        return self._clima[3] == ClimaComelitMode.AUTO
+        self._attr_hvac_action = None
+        if _mode == ClimaComelitMode.OFF:
+            self._attr_hvac_action = HVACAction.OFF
+        if not _active:
+            self._attr_hvac_action = HVACAction.IDLE
+        if _mode in API_STATUS:
+            self._attr_hvac_action = API_STATUS[_mode]["hvac_action"]
 
-    @property
-    def target_temperature(self) -> float:
-        """Set target temperature."""
-        return self._clima[4] / 10
+        self._attr_hvac_mode = None
+        if _mode == ClimaComelitMode.OFF:
+            self._attr_hvac_mode = HVACMode.OFF
+        if _automatic:
+            self._attr_hvac_mode = HVACMode.AUTO
+        if _mode in API_STATUS:
+            self._attr_hvac_mode = API_STATUS[_mode]["hvac_mode"]
 
-    @property
-    def current_temperature(self) -> float:
-        """Return current temperature."""
-        return self._clima[0] / 10
-
-    @property
-    def hvac_mode(self) -> HVACMode | None:
-        """HVAC current mode."""
-
-        if self._api_mode == ClimaComelitMode.OFF:
-            return HVACMode.OFF
-
-        if self._api_automatic:
-            return HVACMode.AUTO
-
-        if self._api_mode in API_STATUS:
-            return API_STATUS[self._api_mode]["hvac_mode"]
-
-        return None
-
-    @property
-    def hvac_action(self) -> HVACAction | None:
-        """HVAC current action."""
-
-        if self._api_mode == ClimaComelitMode.OFF:
-            return HVACAction.OFF
-
-        if not self._api_active:
-            return HVACAction.IDLE
-
-        if self._api_mode in API_STATUS:
-            return API_STATUS[self._api_mode]["hvac_action"]
-
-        return None
+        self._attr_target_temperature = values[4] / 10
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set new target temperature."""

homeassistant/components/comelit/coordinator.py

@@ -2,18 +2,19 @@
 
 from abc import abstractmethod
 from datetime import timedelta
-from typing import Any
+from typing import TypeVar
 
-from aiocomelit import (
+from aiocomelit.api import (
+    AlarmDataObject,
+    ComelitCommonApi,
     ComeliteSerialBridgeApi,
     ComelitSerialBridgeObject,
     ComelitVedoApi,
     ComelitVedoAreaObject,
     ComelitVedoZoneObject,
-    exceptions,
 )
-from aiocomelit.api import ComelitCommonApi
 from aiocomelit.const import BRIDGE, VEDO
+from aiocomelit.exceptions import CannotAuthenticate, CannotConnect, CannotRetrieveData
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -26,7 +27,13 @@ from .const import _LOGGER, DOMAIN
 type ComelitConfigEntry = ConfigEntry[ComelitBaseCoordinator]
 
 
-class ComelitBaseCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+T = TypeVar(
+    "T",
+    bound=dict[str, dict[int, ComelitSerialBridgeObject]] | AlarmDataObject,
+)
+
+
+class ComelitBaseCoordinator(DataUpdateCoordinator[T]):
     """Base coordinator for Comelit Devices."""
 
     _hw_version: str
@@ -81,23 +88,25 @@ class ComelitBaseCoordinator(DataUpdateCoordinator[dict[str, Any]]):
             hw_version=self._hw_version,
         )
 
-    async def _async_update_data(self) -> dict[str, Any]:
+    async def _async_update_data(self) -> T:
         """Update device data."""
         _LOGGER.debug("Polling Comelit %s host: %s", self._device, self._host)
         try:
             await self.api.login()
             return await self._async_update_system_data()
-        except (exceptions.CannotConnect, exceptions.CannotRetrieveData) as err:
+        except (CannotConnect, CannotRetrieveData) as err:
             raise UpdateFailed(repr(err)) from err
-        except exceptions.CannotAuthenticate as err:
+        except CannotAuthenticate as err:
             raise ConfigEntryAuthFailed from err
 
     @abstractmethod
-    async def _async_update_system_data(self) -> dict[str, Any]:
+    async def _async_update_system_data(self) -> T:
         """Class method for updating data."""
 
 
-class ComelitSerialBridge(ComelitBaseCoordinator):
+class ComelitSerialBridge(
+    ComelitBaseCoordinator[dict[str, dict[int, ComelitSerialBridgeObject]]]
+):
     """Queries Comelit Serial Bridge."""
 
     _hw_version = "20003101"
@@ -115,12 +124,14 @@ class ComelitSerialBridge(ComelitBaseCoordinator):
         self.api = ComeliteSerialBridgeApi(host, port, pin)
         super().__init__(hass, entry, BRIDGE, host)
 
-    async def _async_update_system_data(self) -> dict[str, Any]:
+    async def _async_update_system_data(
+        self,
+    ) -> dict[str, dict[int, ComelitSerialBridgeObject]]:
         """Specific method for updating data."""
         return await self.api.get_all_devices()
 
 
-class ComelitVedoSystem(ComelitBaseCoordinator):
+class ComelitVedoSystem(ComelitBaseCoordinator[AlarmDataObject]):
     """Queries Comelit VEDO system."""
 
     _hw_version = "VEDO IP"
@@ -138,6 +149,8 @@ class ComelitVedoSystem(ComelitBaseCoordinator):
         self.api = ComelitVedoApi(host, port, pin)
         super().__init__(hass, entry, VEDO, host)
 
-    async def _async_update_system_data(self) -> dict[str, Any]:
+    async def _async_update_system_data(
+        self,
+    ) -> AlarmDataObject:
         """Specific method for updating data."""
         return await self.api.get_all_areas_and_zones()

homeassistant/components/comelit/humidifier.py

@@ -16,8 +16,8 @@ from homeassistant.components.humidifier import (
     HumidifierEntity,
     HumidifierEntityFeature,
 )
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ServiceValidationError
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -122,61 +122,32 @@ class ComelitHumidifierEntity(CoordinatorEntity[ComelitSerialBridge], Humidifier
         self._active_action = active_action
         self._set_command = set_command
 
-    @property
-    def _humidifier(self) -> list[Any]:
-        """Return humidifier device data."""
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        device = self.coordinator.data[CLIMATE][self._device.index]
+        if not isinstance(device.val, list):
+            raise HomeAssistantError("Invalid clima data")
+
         # CLIMATE has a 2 item tuple:
         # - first  for Clima
         # - second for Humidifier
-        return self.coordinator.data[CLIMATE][self._device.index].val[1]
+        values = device.val[1]
 
-    @property
-    def _api_mode(self) -> str:
-        """Return device mode."""
-        # Values from API: "O", "L", "U"
-        return self._humidifier[2]
+        _active = values[1]
+        _mode = values[2]  # Values from API: "O", "L", "U"
+        _automatic = values[3] == HumidifierComelitMode.AUTO
 
-    @property
-    def _api_active(self) -> bool:
-        "Return device active/idle."
-        return self._humidifier[1]
+        self._attr_action = HumidifierAction.IDLE
+        if _mode == HumidifierComelitMode.OFF:
+            self._attr_action = HumidifierAction.OFF
+        if _active and _mode == self._active_mode:
+            self._attr_action = self._active_action
 
-    @property
-    def _api_automatic(self) -> bool:
-        """Return device in automatic/manual mode."""
-        return self._humidifier[3] == HumidifierComelitMode.AUTO
-
-    @property
-    def target_humidity(self) -> float:
-        """Set target humidity."""
-        return self._humidifier[4] / 10
-
-    @property
-    def current_humidity(self) -> float:
-        """Return current humidity."""
-        return self._humidifier[0] / 10
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return true is humidifier is on."""
-        return self._api_mode == self._active_mode
-
-    @property
-    def mode(self) -> str | None:
-        """Return current mode."""
-        return MODE_AUTO if self._api_automatic else MODE_NORMAL
-
-    @property
-    def action(self) -> HumidifierAction | None:
-        """Return current action."""
-
-        if self._api_mode == HumidifierComelitMode.OFF:
-            return HumidifierAction.OFF
-
-        if self._api_active and self._api_mode == self._active_mode:
-            return self._active_action
-
-        return HumidifierAction.IDLE
+        self._attr_current_humidity = values[0] / 10
+        self._attr_is_on = _mode == self._active_mode
+        self._attr_mode = MODE_AUTO if _automatic else MODE_NORMAL
+        self._attr_target_humidity = values[4] / 10
 
     async def async_set_humidity(self, humidity: int) -> None:
         """Set new target humidity."""

homeassistant/components/comelit/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aiocomelit"],
-  "requirements": ["aiocomelit==0.11.1"]
+  "requirements": ["aiocomelit==0.11.2"]
 }

homeassistant/components/comelit/sensor.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from typing import Final, cast
 
 from aiocomelit import ComelitSerialBridgeObject, ComelitVedoZoneObject
-from aiocomelit.const import ALARM_ZONES, BRIDGE, OTHER, AlarmZoneState
+from aiocomelit.const import BRIDGE, OTHER, AlarmZoneState
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -82,7 +82,7 @@ async def async_setup_vedo_entry(
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
     entities: list[ComelitVedoSensorEntity] = []
-    for device in coordinator.data[ALARM_ZONES].values():
+    for device in coordinator.data["alarm_zones"].values():
         entities.extend(
             ComelitVedoSensorEntity(
                 coordinator, device, config_entry.entry_id, sensor_desc
@@ -119,9 +119,12 @@ class ComelitBridgeSensorEntity(CoordinatorEntity[ComelitSerialBridge], SensorEn
     @property
     def native_value(self) -> StateType:
         """Sensor value."""
-        return getattr(
-            self.coordinator.data[OTHER][self._device.index],
-            self.entity_description.key,
+        return cast(
+            StateType,
+            getattr(
+                self.coordinator.data[OTHER][self._device.index],
+                self.entity_description.key,
+            ),
         )
 
 
@@ -139,7 +142,7 @@ class ComelitVedoSensorEntity(CoordinatorEntity[ComelitVedoSystem], SensorEntity
     ) -> None:
         """Init sensor entity."""
         self._api = coordinator.api
-        self._zone = zone
+        self._zone_index = zone.index
         super().__init__(coordinator)
         # Use config_entry.entry_id as base for unique_id
         # because no serial number or mac is available
@@ -151,7 +154,7 @@ class ComelitVedoSensorEntity(CoordinatorEntity[ComelitVedoSystem], SensorEntity
     @property
     def _zone_object(self) -> ComelitVedoZoneObject:
         """Zone object."""
-        return self.coordinator.data[ALARM_ZONES][self._zone.index]
+        return self.coordinator.data["alarm_zones"][self._zone_index]
 
     @property
     def available(self) -> bool:
@@ -164,4 +167,4 @@ class ComelitVedoSensorEntity(CoordinatorEntity[ComelitVedoSystem], SensorEntity
         if (status := self._zone_object.human_status) == AlarmZoneState.UNKNOWN:
             return None
 
-        return status.value
+        return cast(str, status.value)

homeassistant/components/comelit/switch.py

@@ -77,7 +77,4 @@ class ComelitSwitchEntity(CoordinatorEntity[ComelitSerialBridge], SwitchEntity):
     @property
     def is_on(self) -> bool:
         """Return True if switch is on."""
-        return (
-            self.coordinator.data[self._device.type][self._device.index].status
-            == STATE_ON
-        )
+        return self.coordinator.data[OTHER][self._device.index].status == STATE_ON

homeassistant/components/conversation/chat_log.py

@@ -49,7 +49,11 @@ def async_get_chat_log(
             raise RuntimeError(
                 "Cannot attach chat log delta listener unless initial caller"
             )
-        if user_input is not None:
+        if user_input is not None and (
+            (content := chat_log.content[-1]).role != "user"
+            # MyPy doesn't understand that content is a UserContent here
+            or content.content != user_input.text  # type: ignore[union-attr]
+        ):
             chat_log.async_add_user_content(UserContent(content=user_input.text))
 
         yield chat_log
@@ -179,6 +183,25 @@ class ChatLog:
     llm_api: llm.APIInstance | None = None
     delta_listener: Callable[[ChatLog, dict], None] | None = None
 
+    @property
+    def continue_conversation(self) -> bool:
+        """Return whether the conversation should continue."""
+        if not self.content:
+            return False
+
+        last_msg = self.content[-1]
+
+        return (
+            last_msg.role == "assistant"
+            and last_msg.content is not None  # type: ignore[union-attr]
+            and last_msg.content.strip().endswith(  # type: ignore[union-attr]
+                (
+                    "?",
+                    ";",  # Greek question mark
+                )
+            )
+        )
+
     @property
     def unresponded_tool_results(self) -> bool:
         """Return if there are unresponded tool results."""

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["hassil==2.2.3", "home-assistant-intents==2025.2.26"]
+  "requirements": ["hassil==2.2.3", "home-assistant-intents==2025.3.5"]
 }

homeassistant/components/dhcp/manifest.json

@@ -16,6 +16,6 @@
   "requirements": [
     "aiodhcpwatcher==1.1.1",
     "aiodiscover==2.6.1",
-    "cached-ipaddress==0.9.2"
+    "cached-ipaddress==0.10.0"
   ]
 }

homeassistant/components/ecowitt/manifest.json

@@ -6,5 +6,5 @@
   "dependencies": ["webhook"],
   "documentation": "https://www.home-assistant.io/integrations/ecowitt",
   "iot_class": "local_push",
-  "requirements": ["aioecowitt==2024.2.1"]
+  "requirements": ["aioecowitt==2025.3.1"]
 }

homeassistant/components/elevenlabs/strings.json

@@ -6,7 +6,7 @@
           "api_key": "[%key:common::config_flow::data::api_key%]"
         },
         "data_description": {
-          "api_key": "Your Elevenlabs API key."
+          "api_key": "Your ElevenLabs API key."
         }
       }
     },

homeassistant/components/emulated_kasa/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_push",
   "loggers": ["sense_energy"],
   "quality_scale": "internal",
-  "requirements": ["sense-energy==0.13.5"]
+  "requirements": ["sense-energy==0.13.6"]
 }

homeassistant/components/epson/config_flow.py

@@ -72,5 +72,7 @@ class EpsonConfigFlow(ConfigFlow, domain=DOMAIN):
                 if projector:
                     projector.close()
         return self.async_show_form(
-            step_id="user", data_schema=DATA_SCHEMA, errors=errors
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(DATA_SCHEMA, user_input),
+            errors=errors,
         )

homeassistant/components/eq3btsmart/manifest.json

@@ -22,5 +22,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["eq3btsmart"],
-  "requirements": ["eq3btsmart==1.4.1", "bleak-esphome==2.9.0"]
+  "requirements": ["eq3btsmart==1.4.1", "bleak-esphome==2.11.0"]
 }

homeassistant/components/esphome/const.py

@@ -14,7 +14,7 @@ DEFAULT_ALLOW_SERVICE_CALLS = True
 DEFAULT_NEW_CONFIG_ALLOW_ALLOW_SERVICE_CALLS = False
 
 
-STABLE_BLE_VERSION_STR = "2025.2.1"
+STABLE_BLE_VERSION_STR = "2025.2.2"
 STABLE_BLE_VERSION = AwesomeVersion(STABLE_BLE_VERSION_STR)
 PROJECT_URLS = {
     "esphome.bluetooth-proxy": "https://esphome.github.io/bluetooth-proxies/",

homeassistant/components/esphome/manifest.json

@@ -16,9 +16,9 @@
   "loggers": ["aioesphomeapi", "noiseprotocol", "bleak_esphome"],
   "mqtt": ["esphome/discover/#"],
   "requirements": [
-    "aioesphomeapi==29.3.1",
+    "aioesphomeapi==29.4.0",
     "esphome-dashboard-api==1.2.3",
-    "bleak-esphome==2.9.0"
+    "bleak-esphome==2.11.0"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/evohome/coordinator.py

@@ -11,6 +11,7 @@ from typing import Any
 import evohomeasync as ec1
 import evohomeasync2 as ec2
 from evohomeasync2.const import (
+    SZ_DHW,
     SZ_GATEWAY_ID,
     SZ_GATEWAY_INFO,
     SZ_GATEWAYS,
@@ -19,8 +20,9 @@ from evohomeasync2.const import (
     SZ_TEMPERATURE_CONTROL_SYSTEMS,
     SZ_TIME_ZONE,
     SZ_USE_DAYLIGHT_SAVE_SWITCHING,
+    SZ_ZONES,
 )
-from evohomeasync2.schemas.typedefs import EvoLocStatusResponseT
+from evohomeasync2.schemas.typedefs import EvoLocStatusResponseT, EvoTcsConfigResponseT
 
 from homeassistant.const import CONF_SCAN_INTERVAL
 from homeassistant.core import HomeAssistant
@@ -113,17 +115,19 @@ class EvoDataUpdateCoordinator(DataUpdateCoordinator):
                     SZ_USE_DAYLIGHT_SAVE_SWITCHING
                 ],
             }
+            tcs_info: EvoTcsConfigResponseT = self.tcs.config  # type: ignore[assignment]
+            tcs_info[SZ_ZONES] = [zone.config for zone in self.tcs.zones]
+            if self.tcs.hotwater:
+                tcs_info[SZ_DHW] = self.tcs.hotwater.config
             gwy_info = {
                 SZ_GATEWAY_ID: self.loc.gateways[0].id,
-                SZ_TEMPERATURE_CONTROL_SYSTEMS: [
-                    self.loc.gateways[0].systems[0].config
-                ],
+                SZ_TEMPERATURE_CONTROL_SYSTEMS: [tcs_info],
             }
             config = {
                 SZ_LOCATION_INFO: loc_info,
                 SZ_GATEWAYS: [{SZ_GATEWAY_INFO: gwy_info}],
             }
-            self.logger.debug("Config = %s", config)
+            self.logger.debug("Config = %s", [config])
 
     async def call_client_api(
         self,
@@ -203,10 +207,18 @@ class EvoDataUpdateCoordinator(DataUpdateCoordinator):
 
     async def _update_v2_schedules(self) -> None:
         for zone in self.tcs.zones:
-            await zone.get_schedule()
+            try:
+                await zone.get_schedule()
+            except ec2.InvalidScheduleError as err:
+                self.logger.warning(
+                    "Zone '%s' has an invalid/missing schedule: %r", zone.name, err
+                )
 
         if dhw := self.tcs.hotwater:
-            await dhw.get_schedule()
+            try:
+                await dhw.get_schedule()
+            except ec2.InvalidScheduleError as err:
+                self.logger.warning("DHW has an invalid/missing schedule: %r", err)
 
     async def _async_update_data(self) -> EvoLocStatusResponseT:  # type: ignore[override]
         """Fetch the latest state of an entire TCC Location.

homeassistant/components/evohome/entity.py

@@ -6,6 +6,7 @@ import logging
 from typing import Any
 
 import evohomeasync2 as evo
+from evohomeasync2.schemas.typedefs import DayOfWeekDhwT
 
 from homeassistant.core import callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -102,7 +103,7 @@ class EvoChild(EvoEntity):
 
         self._evo_tcs = evo_device.tcs
 
-        self._schedule: dict[str, Any] | None = None
+        self._schedule: list[DayOfWeekDhwT] | None = None
         self._setpoints: dict[str, Any] = {}
 
     @property
@@ -123,6 +124,9 @@ class EvoChild(EvoEntity):
         Only Zones & DHW controllers (but not the TCS) can have schedules.
         """
 
+        if not self._schedule:
+            return self._setpoints
+
         this_sp_dtm, this_sp_val = self._evo_device.this_switchpoint
         next_sp_dtm, next_sp_val = self._evo_device.next_switchpoint
 
@@ -152,10 +156,10 @@ class EvoChild(EvoEntity):
                     self._evo_device,
                     err,
                 )
-                self._schedule = {}
+                self._schedule = []
                 return
             else:
-                self._schedule = schedule or {}  # mypy hint
+                self._schedule = schedule  # type: ignore[assignment]
 
             _LOGGER.debug("Schedule['%s'] = %s", self.name, schedule)
 

homeassistant/components/forked_daapd/__init__.py

@@ -1,29 +1,36 @@
 """The forked_daapd component."""
 
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
+from pyforked_daapd import ForkedDaapdAPI
 
-from .const import DOMAIN, HASS_DATA_UPDATER_KEY
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .coordinator import ForkedDaapdConfigEntry, ForkedDaapdUpdater
 
 PLATFORMS = [Platform.MEDIA_PLAYER]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ForkedDaapdConfigEntry) -> bool:
     """Set up forked-daapd from a config entry by forwarding to platform."""
+    host: str = entry.data[CONF_HOST]
+    port: int = entry.data[CONF_PORT]
+    password: str = entry.data[CONF_PASSWORD]
+    forked_daapd_api = ForkedDaapdAPI(
+        async_get_clientsession(hass), host, port, password
+    )
+    forked_daapd_updater = ForkedDaapdUpdater(hass, forked_daapd_api, entry.entry_id)
+    entry.runtime_data = forked_daapd_updater
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(
+    hass: HomeAssistant, entry: ForkedDaapdConfigEntry
+) -> bool:
     """Remove forked-daapd component."""
     status = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
-    if status and hass.data.get(DOMAIN) and hass.data[DOMAIN].get(entry.entry_id):
-        if websocket_handler := hass.data[DOMAIN][entry.entry_id][
-            HASS_DATA_UPDATER_KEY
-        ].websocket_handler:
+    if status:
+        if websocket_handler := entry.runtime_data.websocket_handler:
             websocket_handler.cancel()
-        del hass.data[DOMAIN][entry.entry_id]
-        if not hass.data[DOMAIN]:
-            del hass.data[DOMAIN]
     return status

homeassistant/components/forked_daapd/config_flow.py

@@ -7,12 +7,7 @@ from typing import Any
 from pyforked_daapd import ForkedDaapdAPI
 import voluptuous as vol
 
-from homeassistant.config_entries import (
-    ConfigEntry,
-    ConfigFlow,
-    ConfigFlowResult,
-    OptionsFlow,
-)
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult, OptionsFlow
 from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -28,6 +23,7 @@ from .const import (
     DEFAULT_TTS_VOLUME,
     DOMAIN,
 )
+from .coordinator import ForkedDaapdConfigEntry
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -115,7 +111,7 @@ class ForkedDaapdFlowHandler(ConfigFlow, domain=DOMAIN):
     @staticmethod
     @callback
     def async_get_options_flow(
-        config_entry: ConfigEntry,
+        config_entry: ForkedDaapdConfigEntry,
     ) -> ForkedDaapdOptionsFlowHandler:
         """Return options flow handler."""
         return ForkedDaapdOptionsFlowHandler()

homeassistant/components/forked_daapd/const.py

@@ -30,9 +30,8 @@ DEFAULT_SERVER_NAME = "My Server"
 DEFAULT_TTS_PAUSE_TIME = 1.2
 DEFAULT_TTS_VOLUME = 0.8
 DEFAULT_UNMUTE_VOLUME = 0.6
-DOMAIN = "forked_daapd"  # key for hass.data
+DOMAIN = "forked_daapd"
 FD_NAME = "OwnTone"
-HASS_DATA_UPDATER_KEY = "UPDATER"
 KNOWN_PIPES = {"librespot-java"}
 PIPE_FUNCTION_MAP = {
     "librespot-java": {

homeassistant/components/forked_daapd/coordinator.py

@@ -9,6 +9,7 @@ from typing import Any
 
 from pyforked_daapd import ForkedDaapdAPI
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers.dispatcher import async_dispatcher_send
@@ -22,6 +23,8 @@ from .const import (
     SIGNAL_UPDATE_QUEUE,
 )
 
+type ForkedDaapdConfigEntry = ConfigEntry[ForkedDaapdUpdater]
+
 _LOGGER = logging.getLogger(__name__)
 
 WS_NOTIFY_EVENT_TYPES = ["player", "outputs", "volume", "options", "queue", "database"]
@@ -39,6 +42,11 @@ class ForkedDaapdUpdater:
         self._all_output_ids: set[str] = set()
         self._entry_id = entry_id
 
+    @property
+    def api(self) -> ForkedDaapdAPI:
+        """Return the API object."""
+        return self._api
+
     async def async_init(self) -> None:
         """Perform async portion of class initialization."""
         if not (server_config := await self._api.get_request("config")):

homeassistant/components/forked_daapd/media_player.py

@@ -7,7 +7,6 @@ from collections import defaultdict
 import logging
 from typing import Any
 
-from pyforked_daapd import ForkedDaapdAPI
 from pylibrespot_java import LibrespotJavaAPI
 
 from homeassistant.components import media_source
@@ -28,8 +27,7 @@ from homeassistant.components.spotify import (
     resolve_spotify_media_type,
     spotify_uri_from_media_browser_url,
 )
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT
+from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.dispatcher import (
@@ -55,9 +53,7 @@ from .const import (
     DEFAULT_TTS_PAUSE_TIME,
     DEFAULT_TTS_VOLUME,
     DEFAULT_UNMUTE_VOLUME,
-    DOMAIN,
     FD_NAME,
-    HASS_DATA_UPDATER_KEY,
     KNOWN_PIPES,
     PIPE_FUNCTION_MAP,
     SIGNAL_ADD_ZONES,
@@ -74,23 +70,21 @@ from .const import (
     SUPPORTED_FEATURES_ZONE,
     TTS_TIMEOUT,
 )
-from .coordinator import ForkedDaapdUpdater
+from .coordinator import ForkedDaapdConfigEntry
 
 _LOGGER = logging.getLogger(__name__)
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: ForkedDaapdConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up forked-daapd from a config entry."""
+    forked_daapd_updater = config_entry.runtime_data
+
     host: str = config_entry.data[CONF_HOST]
-    port: int = config_entry.data[CONF_PORT]
-    password: str = config_entry.data[CONF_PASSWORD]
-    forked_daapd_api = ForkedDaapdAPI(
-        async_get_clientsession(hass), host, port, password
-    )
+    forked_daapd_api = forked_daapd_updater.api
     forked_daapd_master = ForkedDaapdMaster(
         clientsession=async_get_clientsession(hass),
         api=forked_daapd_api,
@@ -111,20 +105,12 @@ async def async_setup_entry(
     )
     config_entry.async_on_unload(config_entry.add_update_listener(update_listener))
 
-    if not hass.data.get(DOMAIN):
-        hass.data[DOMAIN] = {config_entry.entry_id: {}}
-
     async_add_entities([forked_daapd_master], False)
-    forked_daapd_updater = ForkedDaapdUpdater(
-        hass, forked_daapd_api, config_entry.entry_id
-    )
-    hass.data[DOMAIN][config_entry.entry_id][HASS_DATA_UPDATER_KEY] = (
-        forked_daapd_updater
-    )
+
     await forked_daapd_updater.async_init()
 
 
-async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
+async def update_listener(hass: HomeAssistant, entry: ForkedDaapdConfigEntry) -> None:
     """Handle options update."""
     async_dispatcher_send(
         hass, SIGNAL_CONFIG_OPTIONS_UPDATE.format(entry.entry_id), entry.options

homeassistant/components/frontend/manifest.json

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

homeassistant/components/fully_kiosk/strings.json

@@ -1,6 +1,6 @@
 {
   "common": {
-    "data_description_password": "The Remote Admin Password from the Fully Kiosk Browser app settings.",
+    "data_description_password": "The Remote Admin password from the Fully Kiosk Browser app settings.",
     "data_description_ssl": "Is the Fully Kiosk app configured to require SSL for the connection?",
     "data_description_verify_ssl": "Should SSL certificartes be verified? This should be off for self-signed certificates."
   },
@@ -151,7 +151,7 @@
       }
     },
     "set_config": {
-      "name": "Set Configuration",
+      "name": "Set configuration",
       "description": "Sets a configuration parameter on Fully Kiosk Browser.",
       "fields": {
         "key": {
@@ -165,7 +165,7 @@
       }
     },
     "start_application": {
-      "name": "Start Application",
+      "name": "Start application",
       "description": "Starts an application on the device running Fully Kiosk Browser.",
       "fields": {
         "application": {

homeassistant/components/geocaching/manifest.json

@@ -6,5 +6,5 @@
   "dependencies": ["application_credentials"],
   "documentation": "https://www.home-assistant.io/integrations/geocaching",
   "iot_class": "cloud_polling",
-  "requirements": ["geocachingapi==0.2.1"]
+  "requirements": ["geocachingapi==0.3.0"]
 }

homeassistant/components/gios/__init__.py

@@ -4,9 +4,14 @@ from __future__ import annotations
 
 import logging
 
+from aiohttp.client_exceptions import ClientConnectorError
+from gios import Gios
+from gios.exceptions import GiosError
+
 from homeassistant.components.air_quality import DOMAIN as AIR_QUALITY_PLATFORM
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
@@ -36,8 +41,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: GiosConfigEntry) -> bool
         device_registry.async_update_device(device_entry.id, new_identifiers={new_ids})
 
     websession = async_get_clientsession(hass)
+    try:
+        gios = await Gios.create(websession, station_id)
+    except (GiosError, ConnectionError, ClientConnectorError) as err:
+        raise ConfigEntryNotReady from err
 
-    coordinator = GiosDataUpdateCoordinator(hass, entry, websession, station_id)
+    coordinator = GiosDataUpdateCoordinator(hass, entry, gios)
     await coordinator.async_config_entry_first_refresh()
 
     entry.runtime_data = GiosData(coordinator)

homeassistant/components/gios/config_flow.py

@@ -37,7 +37,7 @@ class GiosFlowHandler(ConfigFlow, domain=DOMAIN):
                 websession = async_get_clientsession(self.hass)
 
                 async with asyncio.timeout(API_TIMEOUT):
-                    gios = Gios(user_input[CONF_STATION_ID], websession)
+                    gios = await Gios.create(websession, user_input[CONF_STATION_ID])
                     await gios.async_update()
 
                 assert gios.station_name is not None

homeassistant/components/gios/const.py

@@ -13,7 +13,7 @@ SCAN_INTERVAL: Final = timedelta(minutes=30)
 DOMAIN: Final = "gios"
 MANUFACTURER: Final = "Główny Inspektorat Ochrony Środowiska"
 
-URL = "http://powietrze.gios.gov.pl/pjp/current/station_details/info/{station_id}"
+URL = "https://powietrze.gios.gov.pl/pjp/current/station_details/info/{station_id}"
 
 API_TIMEOUT: Final = 30
 

homeassistant/components/gios/coordinator.py

@@ -6,7 +6,6 @@ import asyncio
 from dataclasses import dataclass
 import logging
 
-from aiohttp import ClientSession
 from aiohttp.client_exceptions import ClientConnectorError
 from gios import Gios
 from gios.exceptions import GiosError
@@ -39,11 +38,10 @@ class GiosDataUpdateCoordinator(DataUpdateCoordinator[GiosSensors]):
         self,
         hass: HomeAssistant,
         config_entry: GiosConfigEntry,
-        session: ClientSession,
-        station_id: int,
+        gios: Gios,
     ) -> None:
         """Class to manage fetching GIOS data API."""
-        self.gios = Gios(station_id, session)
+        self.gios = gios
 
         super().__init__(
             hass,

homeassistant/components/gios/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["dacite", "gios"],
-  "requirements": ["gios==5.0.0"]
+  "requirements": ["gios==6.0.0"]
 }

homeassistant/components/google_drive/backup.py

@@ -8,7 +8,12 @@ from typing import Any
 
 from google_drive_api.exceptions import GoogleDriveApiError
 
-from homeassistant.components.backup import AgentBackup, BackupAgent, BackupAgentError
+from homeassistant.components.backup import (
+    AgentBackup,
+    BackupAgent,
+    BackupAgentError,
+    BackupNotFound,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import ChunkAsyncStreamIterator
@@ -93,13 +98,13 @@ class GoogleDriveBackupAgent(BackupAgent):
         self,
         backup_id: str,
         **kwargs: Any,
-    ) -> AgentBackup | None:
+    ) -> AgentBackup:
         """Return a backup."""
         backups = await self.async_list_backups()
         for backup in backups:
             if backup.backup_id == backup_id:
                 return backup
-        return None
+        raise BackupNotFound(f"Backup {backup_id} not found")
 
     async def async_download_backup(
         self,
@@ -120,7 +125,7 @@ class GoogleDriveBackupAgent(BackupAgent):
                 return ChunkAsyncStreamIterator(stream)
         except (GoogleDriveApiError, HomeAssistantError, TimeoutError) as err:
             raise BackupAgentError(f"Failed to download backup: {err}") from err
-        raise BackupAgentError("Backup not found")
+        raise BackupNotFound(f"Backup {backup_id} not found")
 
     async def async_delete_backup(
         self,
@@ -138,5 +143,7 @@ class GoogleDriveBackupAgent(BackupAgent):
                 _LOGGER.debug("Deleting file_id: %s", file_id)
                 await self._client.async_delete(file_id)
                 _LOGGER.debug("Deleted backup_id: %s", backup_id)
+                return
         except (GoogleDriveApiError, HomeAssistantError, TimeoutError) as err:
             raise BackupAgentError(f"Failed to delete backup: {err}") from err
+        raise BackupNotFound(f"Backup {backup_id} not found")

homeassistant/components/google_generative_ai_conversation/__init__.py

@@ -65,9 +65,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
         prompt_parts = [call.data[CONF_PROMPT]]
 
-        config_entry: GoogleGenerativeAIConfigEntry = hass.config_entries.async_entries(
-            DOMAIN
-        )[0]
+        config_entry: GoogleGenerativeAIConfigEntry = (
+            hass.config_entries.async_loaded_entries(DOMAIN)[0]
+        )
 
         client = config_entry.runtime_data
 

homeassistant/components/google_generative_ai_conversation/conversation.py

@@ -64,28 +64,18 @@ async def async_setup_entry(
 
 
 SUPPORTED_SCHEMA_KEYS = {
-    "min_items",
-    "example",
-    "property_ordering",
-    "pattern",
-    "minimum",
-    "default",
-    "any_of",
-    "max_length",
-    "title",
-    "min_properties",
-    "min_length",
-    "max_items",
-    "maximum",
-    "nullable",
-    "max_properties",
+    # Gemini API does not support all of the OpenAPI schema
+    # SoT: https://ai.google.dev/api/caching#Schema
     "type",
-    "description",
-    "enum",
     "format",
-    "items",
+    "description",
+    "nullable",
+    "enum",
+    "max_items",
+    "min_items",
     "properties",
     "required",
+    "items",
 }
 
 
@@ -109,9 +99,7 @@ def _format_schema(schema: dict[str, Any]) -> Schema:
         key = _camel_to_snake(key)
         if key not in SUPPORTED_SCHEMA_KEYS:
             continue
-        if key == "any_of":
-            val = [_format_schema(subschema) for subschema in val]
-        elif key == "type":
+        if key == "type":
             val = val.upper()
         elif key == "format":
             # Gemini API does not support all formats, see: https://ai.google.dev/api/caching#Schema
@@ -471,7 +459,9 @@ class GoogleGenerativeAIConversationEntity(
             " ".join([part.text.strip() for part in response_parts if part.text])
         )
         return conversation.ConversationResult(
-            response=response, conversation_id=chat_log.conversation_id
+            response=response,
+            conversation_id=chat_log.conversation_id,
+            continue_conversation=chat_log.continue_conversation,
         )
 
     async def _async_entry_update_listener(

homeassistant/components/habitica/const.py

@@ -62,6 +62,7 @@ SERVICE_TRANSFORMATION = "transformation"
 SERVICE_UPDATE_REWARD = "update_reward"
 SERVICE_CREATE_REWARD = "create_reward"
 SERVICE_UPDATE_HABIT = "update_habit"
+SERVICE_CREATE_HABIT = "create_habit"
 
 DEVELOPER_ID = "4c4ca53f-c059-4ffa-966e-9d29dd405daf"
 X_CLIENT = f"{DEVELOPER_ID} - {APPLICATION_NAME} {__version__}"

homeassistant/components/habitica/icons.json

@@ -237,6 +237,12 @@
         "tag_options": "mdi:tag",
         "developer_options": "mdi:test-tube"
       }
+    },
+    "create_habit": {
+      "service": "mdi:contrast-box",
+      "sections": {
+        "developer_options": "mdi:test-tube"
+      }
     }
   }
 }

homeassistant/components/habitica/services.py

@@ -66,6 +66,7 @@ from .const import (
     SERVICE_API_CALL,
     SERVICE_CANCEL_QUEST,
     SERVICE_CAST_SKILL,
+    SERVICE_CREATE_HABIT,
     SERVICE_CREATE_REWARD,
     SERVICE_GET_TASKS,
     SERVICE_LEAVE_QUEST,
@@ -190,6 +191,7 @@ SERVICE_TASK_TYPE_MAP = {
     SERVICE_UPDATE_REWARD: TaskType.REWARD,
     SERVICE_CREATE_REWARD: TaskType.REWARD,
     SERVICE_UPDATE_HABIT: TaskType.HABIT,
+    SERVICE_CREATE_HABIT: TaskType.HABIT,
 }
 
 
@@ -596,7 +598,7 @@ def async_setup_services(hass: HomeAssistant) -> None:  # noqa: C901
         data = Task()
 
         if not is_update:
-            data["type"] = TaskType.REWARD
+            data["type"] = SERVICE_TASK_TYPE_MAP[call.service]
 
         if (text := call.data.get(ATTR_RENAME)) or (text := call.data.get(ATTR_NAME)):
             data["text"] = text
@@ -733,6 +735,13 @@ def async_setup_services(hass: HomeAssistant) -> None:  # noqa: C901
         schema=SERVICE_CREATE_TASK_SCHEMA,
         supports_response=SupportsResponse.ONLY,
     )
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_CREATE_HABIT,
+        create_or_update_task,
+        schema=SERVICE_CREATE_TASK_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
+    )
     hass.services.async_register(
         DOMAIN,
         SERVICE_API_CALL,

homeassistant/components/habitica/services.yaml

@@ -183,7 +183,7 @@ update_reward:
 create_reward:
   fields:
     config_entry: *config_entry
-    name:
+    name: &name
       required: true
       selector:
         text:
@@ -199,7 +199,7 @@ update_habit:
     task: *task
     rename: *rename
     notes: *notes
-    up_down:
+    up_down: &up_down
       required: false
       selector:
         select:
@@ -210,7 +210,7 @@ update_habit:
               label: "➖"
           multiple: true
           mode: list
-    priority:
+    priority: &priority
       required: false
       selector:
         select:
@@ -221,7 +221,7 @@ update_habit:
             - "hard"
           mode: dropdown
           translation_key: "priority"
-    frequency:
+    frequency: &frequency
       required: false
       selector:
         select:
@@ -252,3 +252,13 @@ update_habit:
               unit_of_measurement: "➖"
               mode: box
         alias: *alias
+create_habit:
+  fields:
+    config_entry: *config_entry
+    name: *name
+    notes: *notes
+    up_down: *up_down
+    priority: *priority
+    frequency: *frequency
+    tag: *tag
+    developer_options: *developer_options

homeassistant/components/habitica/strings.json

@@ -11,9 +11,9 @@
     "config_entry_description": "Select the Habitica account to update a task.",
     "task_description": "The name (or task ID) of the task you want to update.",
     "rename_name": "Rename",
-    "rename_description": "The new title for the Habitica task.",
-    "notes_name": "Update notes",
-    "notes_description": "The new notes for the Habitica task.",
+    "rename_description": "The title for the Habitica task.",
+    "notes_name": "Notes",
+    "notes_description": "The notes for the Habitica task.",
     "tag_name": "Add tags",
     "tag_description": "Add tags to the Habitica task. If a tag does not already exist, a new one will be created.",
     "remove_tag_name": "Remove tags",
@@ -25,7 +25,13 @@
     "tag_options_name": "Tags",
     "tag_options_description": "Add or remove tags from a task.",
     "name_description": "The title for the Habitica task.",
-    "cost_name": "Cost"
+    "cost_name": "Cost",
+    "difficulty_name": "Difficulty",
+    "difficulty_description": "The difficulty of the task.",
+    "frequency_name": "Counter reset",
+    "frequency_description": "The frequency at which the habit's counter resets: daily at the start of a new day, weekly after Sunday night, or monthly at the beginning of a new month.",
+    "up_down_name": "Rewards or losses",
+    "up_down_description": "Whether the habit is good and rewarding (positive), bad and penalizing (negative), or both."
   },
   "config": {
     "abort": {
@@ -793,16 +799,16 @@
           "description": "[%key:component::habitica::common::alias_description%]"
         },
         "priority": {
-          "name": "Difficulty",
-          "description": "Update the difficulty of a task."
+          "name": "[%key:component::habitica::common::difficulty_name%]",
+          "description": "[%key:component::habitica::common::difficulty_description%]"
         },
         "frequency": {
-          "name": "Counter reset",
-          "description": "Update when a habit's counter resets: daily resets at the start of a new day, weekly after Sunday night, and monthly at the beginning of a new month."
+          "name": "[%key:component::habitica::common::frequency_name%]",
+          "description": "[%key:component::habitica::common::frequency_description%]"
         },
         "up_down": {
-          "name": "Rewards or losses",
-          "description": "Update if the habit is good and rewarding (positive), bad and penalizing (negative), or both."
+          "name": "[%key:component::habitica::common::up_down_name%]",
+          "description": "[%key:component::habitica::common::up_down_description%]"
         },
         "counter_up": {
           "name": "Adjust positive counter",
@@ -823,6 +829,50 @@
           "description": "[%key:component::habitica::common::developer_options_description%]"
         }
       }
+    },
+    "create_habit": {
+      "name": "Create habit",
+      "description": "Adds a new habit.",
+      "fields": {
+        "config_entry": {
+          "name": "[%key:component::habitica::common::config_entry_name%]",
+          "description": "Select the Habitica account to create a habit."
+        },
+        "name": {
+          "name": "[%key:component::habitica::common::task_name%]",
+          "description": "[%key:component::habitica::common::name_description%]"
+        },
+        "notes": {
+          "name": "[%key:component::habitica::common::notes_name%]",
+          "description": "[%key:component::habitica::common::notes_description%]"
+        },
+        "tag": {
+          "name": "[%key:component::habitica::common::tag_name%]",
+          "description": "[%key:component::habitica::common::tag_description%]"
+        },
+        "alias": {
+          "name": "[%key:component::habitica::common::alias_name%]",
+          "description": "[%key:component::habitica::common::alias_description%]"
+        },
+        "priority": {
+          "name": "[%key:component::habitica::common::difficulty_name%]",
+          "description": "[%key:component::habitica::common::difficulty_description%]"
+        },
+        "frequency": {
+          "name": "[%key:component::habitica::common::frequency_name%]",
+          "description": "[%key:component::habitica::common::frequency_description%]"
+        },
+        "up_down": {
+          "name": "[%key:component::habitica::common::up_down_name%]",
+          "description": "[%key:component::habitica::common::up_down_description%]"
+        }
+      },
+      "sections": {
+        "developer_options": {
+          "name": "[%key:component::habitica::common::developer_options_name%]",
+          "description": "[%key:component::habitica::common::developer_options_description%]"
+        }
+      }
     }
   },
   "selector": {

homeassistant/components/hassio/backup.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import AsyncIterator, Callable, Coroutine, Mapping
+from contextlib import suppress
 import logging
 import os
 from pathlib import Path, PurePath
@@ -173,7 +174,7 @@ class SupervisorBackupAgent(BackupAgent):
                 ),
             )
         except SupervisorNotFoundError as err:
-            raise BackupNotFound from err
+            raise BackupNotFound(f"Backup {backup_id} not found") from err
 
     async def async_upload_backup(
         self,
@@ -186,13 +187,14 @@ class SupervisorBackupAgent(BackupAgent):
 
         The upload will be skipped if the backup already exists in the agent's location.
         """
-        if await self.async_get_backup(backup.backup_id):
-            _LOGGER.debug(
-                "Backup %s already exists in location %s",
-                backup.backup_id,
-                self.location,
-            )
-            return
+        with suppress(BackupNotFound):
+            if await self.async_get_backup(backup.backup_id):
+                _LOGGER.debug(
+                    "Backup %s already exists in location %s",
+                    backup.backup_id,
+                    self.location,
+                )
+                return
         stream = await open_stream()
         upload_options = supervisor_backups.UploadBackupOptions(
             location={self.location},
@@ -218,14 +220,14 @@ class SupervisorBackupAgent(BackupAgent):
         self,
         backup_id: str,
         **kwargs: Any,
-    ) -> AgentBackup | None:
+    ) -> AgentBackup:
         """Return a backup."""
         try:
             details = await self._client.backups.backup_info(backup_id)
-        except SupervisorNotFoundError:
-            return None
+        except SupervisorNotFoundError as err:
+            raise BackupNotFound(f"Backup {backup_id} not found") from err
         if self.location not in details.location_attributes:
-            return None
+            raise BackupNotFound(f"Backup {backup_id} not found")
         return _backup_details_to_agent_backup(details, self.location)
 
     async def async_delete_backup(self, backup_id: str, **kwargs: Any) -> None:
@@ -237,8 +239,8 @@ class SupervisorBackupAgent(BackupAgent):
                     location={self.location}
                 ),
             )
-        except SupervisorNotFoundError:
-            _LOGGER.debug("Backup %s does not exist", backup_id)
+        except SupervisorNotFoundError as err:
+            raise BackupNotFound(f"Backup {backup_id} not found") from err
 
 
 class SupervisorBackupReaderWriter(BackupReaderWriter):
@@ -492,10 +494,12 @@ class SupervisorBackupReaderWriter(BackupReaderWriter):
     ) -> None:
         """Restore a backup."""
         manager = self._hass.data[DATA_MANAGER]
-        # The backup manager has already checked that the backup exists so we don't need to
-        # check that here.
+        # The backup manager has already checked that the backup exists so we don't
+        # need to catch BackupNotFound here.
         backup = await manager.backup_agents[agent_id].async_get_backup(backup_id)
         if (
+            # Check for None to be backwards compatible with the old BackupAgent API,
+            # this can be removed in HA Core 2025.10
             backup
             and restore_homeassistant
             and restore_database != backup.database_included

homeassistant/components/hko/coordinator.py

@@ -11,7 +11,6 @@ from hko import HKO, HKOError
 from homeassistant.components.weather import (
     ATTR_CONDITION_CLOUDY,
     ATTR_CONDITION_FOG,
-    ATTR_CONDITION_HAIL,
     ATTR_CONDITION_LIGHTNING_RAINY,
     ATTR_CONDITION_PARTLYCLOUDY,
     ATTR_CONDITION_POURING,
@@ -145,7 +144,7 @@ class HKOUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         """Return the condition corresponding to the weather info."""
         info = info.lower()
         if WEATHER_INFO_RAIN in info:
-            return ATTR_CONDITION_HAIL
+            return ATTR_CONDITION_RAINY
         if WEATHER_INFO_SNOW in info and WEATHER_INFO_RAIN in info:
             return ATTR_CONDITION_SNOWY_RAINY
         if WEATHER_INFO_SNOW in info:

homeassistant/components/holiday/manifest.json

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

homeassistant/components/home_connect/coordinator.py

@@ -47,8 +47,6 @@ _LOGGER = logging.getLogger(__name__)
 
 type HomeConnectConfigEntry = ConfigEntry[HomeConnectCoordinator]
 
-EVENT_STREAM_RECONNECT_DELAY = 30
-
 
 @dataclass(frozen=True, kw_only=True)
 class HomeConnectApplianceData:
@@ -100,6 +98,7 @@ class HomeConnectCoordinator(
             CALLBACK_TYPE, tuple[CALLBACK_TYPE, tuple[EventKey, ...]]
         ] = {}
         self.device_registry = dr.async_get(self.hass)
+        self.data = {}
 
     @cached_property
     def context_listeners(self) -> dict[tuple[str, EventKey], list[CALLBACK_TYPE]]:
@@ -157,10 +156,20 @@ class HomeConnectCoordinator(
 
     async def _event_listener(self) -> None:
         """Match event with listener for event type."""
+        retry_time = 10
         while True:
             try:
                 async for event_message in self.client.stream_all_events():
+                    retry_time = 10
                     event_message_ha_id = event_message.ha_id
+                    if (
+                        event_message_ha_id in self.data
+                        and not self.data[event_message_ha_id].info.connected
+                    ):
+                        self.data[event_message_ha_id].info.connected = True
+                        self._call_all_event_listeners_for_appliance(
+                            event_message_ha_id
+                        )
                     match event_message.type:
                         case EventType.STATUS:
                             statuses = self.data[event_message_ha_id].status
@@ -256,20 +265,18 @@ class HomeConnectCoordinator(
             except (EventStreamInterruptedError, HomeConnectRequestError) as error:
                 _LOGGER.debug(
                     "Non-breaking error (%s) while listening for events,"
-                    " continuing in 30 seconds",
-                    type(error).__name__,
+                    " continuing in %s seconds",
+                    error,
+                    retry_time,
                 )
-                await asyncio.sleep(EVENT_STREAM_RECONNECT_DELAY)
+                await asyncio.sleep(retry_time)
+                retry_time = min(retry_time * 2, 3600)
             except HomeConnectApiError as error:
                 _LOGGER.error("Error while listening for events: %s", error)
                 self.hass.config_entries.async_schedule_reload(
                     self.config_entry.entry_id
                 )
                 break
-            # if there was a non-breaking error, we continue listening
-            # but we need to refresh the data to get the possible changes
-            # that happened while the event stream was interrupted
-            await self.async_refresh()
 
     @callback
     def _call_event_listener(self, event_message: EventMessage) -> None:
@@ -297,6 +304,8 @@ class HomeConnectCoordinator(
                 translation_placeholders=get_dict_from_home_connect_error(error),
             ) from error
         except HomeConnectError as error:
+            for appliance_data in self.data.values():
+                appliance_data.info.connected = False
             raise UpdateFailed(
                 translation_domain=DOMAIN,
                 translation_key="fetch_api_error",
@@ -305,7 +314,7 @@ class HomeConnectCoordinator(
 
         return {
             appliance.ha_id: await self._get_appliance_data(
-                appliance, self.data.get(appliance.ha_id) if self.data else None
+                appliance, self.data.get(appliance.ha_id)
             )
             for appliance in appliances.homeappliances
         }
@@ -334,9 +343,7 @@ class HomeConnectCoordinator(
             _LOGGER.debug(
                 "Error fetching settings for %s: %s",
                 appliance.ha_id,
-                error
-                if isinstance(error, HomeConnectApiError)
-                else type(error).__name__,
+                error,
             )
             settings = {}
         try:
@@ -348,9 +355,7 @@ class HomeConnectCoordinator(
             _LOGGER.debug(
                 "Error fetching status for %s: %s",
                 appliance.ha_id,
-                error
-                if isinstance(error, HomeConnectApiError)
-                else type(error).__name__,
+                error,
             )
             status = {}
 
@@ -364,9 +369,7 @@ class HomeConnectCoordinator(
                 _LOGGER.debug(
                     "Error fetching programs for %s: %s",
                     appliance.ha_id,
-                    error
-                    if isinstance(error, HomeConnectApiError)
-                    else type(error).__name__,
+                    error,
                 )
             else:
                 programs.extend(all_programs.programs)
@@ -456,9 +459,7 @@ class HomeConnectCoordinator(
             _LOGGER.debug(
                 "Error fetching options for %s: %s",
                 ha_id,
-                error
-                if isinstance(error, HomeConnectApiError)
-                else type(error).__name__,
+                error,
             )
             return {}
 

homeassistant/components/home_connect/entity.py

@@ -8,6 +8,7 @@ from typing import cast
 from aiohomeconnect.model import EventKey, OptionKey
 from aiohomeconnect.model.error import ActiveProgramNotSetError, HomeConnectError
 
+from homeassistant.const import STATE_UNAVAILABLE
 from homeassistant.core import callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -51,8 +52,10 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
     def _handle_coordinator_update(self) -> None:
         """Handle updated data from the coordinator."""
         self.update_native_value()
+        available = self._attr_available = self.appliance.info.connected
         self.async_write_ha_state()
-        _LOGGER.debug("Updated %s, new state: %s", self.entity_id, self.state)
+        state = STATE_UNAVAILABLE if not available else self.state
+        _LOGGER.debug("Updated %s, new state: %s", self.entity_id, state)
 
     @property
     def bsh_key(self) -> str:
@@ -61,10 +64,13 @@ class HomeConnectEntity(CoordinatorEntity[HomeConnectCoordinator]):
 
     @property
     def available(self) -> bool:
-        """Return True if entity is available."""
-        return (
-            self.appliance.info.connected and self._attr_available and super().available
-        )
+        """Return True if entity is available.
+
+        Do not use self.last_update_success for available state
+        as event updates should take precedence over the coordinator
+        refresh.
+        """
+        return self._attr_available
 
 
 class HomeConnectOptionEntity(HomeConnectEntity):

homeassistant/components/home_connect/manifest.json

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

homeassistant/components/home_connect/sensor.py

@@ -386,6 +386,13 @@ class HomeConnectProgramSensor(HomeConnectSensor):
 
     def update_native_value(self) -> None:
         """Update the program sensor's status."""
+        self.program_running = (
+            status := self.appliance.status.get(StatusKey.BSH_COMMON_OPERATION_STATE)
+        ) is not None and status.value in [
+            BSH_OPERATION_STATE_RUN,
+            BSH_OPERATION_STATE_PAUSE,
+            BSH_OPERATION_STATE_FINISHED,
+        ]
         event = self.appliance.events.get(cast(EventKey, self.bsh_key))
         if event:
             self._update_native_value(event.value)

homeassistant/components/home_connect/utils.py

@@ -2,7 +2,7 @@
 
 import re
 
-from aiohomeconnect.model.error import HomeConnectApiError, HomeConnectError
+from aiohomeconnect.model.error import HomeConnectError
 
 RE_CAMEL_CASE = re.compile(r"(?<!^)(?=[A-Z])|(?=\d)(?<=\D)")
 
@@ -11,11 +11,7 @@ def get_dict_from_home_connect_error(
     err: HomeConnectError,
 ) -> dict[str, str]:
     """Return a translation string from a Home Connect error."""
-    return {
-        "error": str(err)
-        if isinstance(err, HomeConnectApiError)
-        else type(err).__name__
-    }
+    return {"error": str(err)}
 
 
 def bsh_key_to_translation_key(bsh_key: str) -> str:

homeassistant/components/homee/__init__.py

@@ -19,6 +19,7 @@ PLATFORMS = [
     Platform.COVER,
     Platform.LIGHT,
     Platform.NUMBER,
+    Platform.SELECT,
     Platform.SENSOR,
     Platform.SWITCH,
     Platform.VALVE,

homeassistant/components/homee/button.py

@@ -15,6 +15,8 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import HomeeConfigEntry
 from .entity import HomeeEntity
 
+PARALLEL_UPDATES = 0
+
 BUTTON_DESCRIPTIONS: dict[AttributeType, ButtonEntityDescription] = {
     AttributeType.AUTOMATIC_MODE_IMPULSE: ButtonEntityDescription(key="automatic_mode"),
     AttributeType.BRIEFLY_OPEN_IMPULSE: ButtonEntityDescription(key="briefly_open"),

homeassistant/components/homee/cover.py

@@ -21,6 +21,8 @@ from .entity import HomeeNodeEntity
 
 _LOGGER = logging.getLogger(__name__)
 
+PARALLEL_UPDATES = 0
+
 OPEN_CLOSE_ATTRIBUTES = [
     AttributeType.OPEN_CLOSE,
     AttributeType.SLAT_ROTATION_IMPULSE,

homeassistant/components/homee/icons.json

@@ -1,6 +1,12 @@
 {
   "entity": {
     "sensor": {
+      "brightness": {
+        "default": "mdi:brightness-5"
+      },
+      "brightness_instance": {
+        "default": "mdi:brightness-5"
+      },
       "link_quality": {
         "default": "mdi:signal"
       },

homeassistant/components/homee/light.py

@@ -32,6 +32,8 @@ LIGHT_ATTRIBUTES = [
     AttributeType.DIMMING_LEVEL,
 ]
 
+PARALLEL_UPDATES = 0
+
 
 def is_light_node(node: HomeeNode) -> bool:
     """Determine if a node is controllable as a homee light based on its profile and attributes."""

homeassistant/components/homee/number.py

@@ -16,6 +16,8 @@ from . import HomeeConfigEntry
 from .const import HOMEE_UNIT_TO_HA_UNIT
 from .entity import HomeeEntity
 
+PARALLEL_UPDATES = 0
+
 NUMBER_DESCRIPTIONS = {
     AttributeType.DOWN_POSITION: NumberEntityDescription(
         key="down_position",

homeassistant/components/homee/quality_scale.yaml

@@ -35,7 +35,7 @@ rules:
   entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
-  parallel-updates: todo
+  parallel-updates: done
   reauthentication-flow: todo
   test-coverage: todo
 

homeassistant/components/homee/select.py

@@ -0,0 +1,63 @@
+"""The Homee select platform."""
+
+from pyHomee.const import AttributeType
+from pyHomee.model import HomeeAttribute
+
+from homeassistant.components.select import SelectEntity, SelectEntityDescription
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import HomeeConfigEntry
+from .entity import HomeeEntity
+
+PARALLEL_UPDATES = 0
+
+SELECT_DESCRIPTIONS: dict[AttributeType, SelectEntityDescription] = {
+    AttributeType.REPEATER_MODE: SelectEntityDescription(
+        key="repeater_mode",
+        options=["off", "level1", "level2"],
+        entity_category=EntityCategory.CONFIG,
+    ),
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: HomeeConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Add the Homee platform for the select component."""
+
+    async_add_entities(
+        HomeeSelect(attribute, config_entry, SELECT_DESCRIPTIONS[attribute.type])
+        for node in config_entry.runtime_data.nodes
+        for attribute in node.attributes
+        if attribute.type in SELECT_DESCRIPTIONS and attribute.editable
+    )
+
+
+class HomeeSelect(HomeeEntity, SelectEntity):
+    """Representation of a Homee select entity."""
+
+    def __init__(
+        self,
+        attribute: HomeeAttribute,
+        entry: HomeeConfigEntry,
+        description: SelectEntityDescription,
+    ) -> None:
+        """Initialize a Homee select entity."""
+        super().__init__(attribute, entry)
+        self.entity_description = description
+        assert description.options is not None
+        self._attr_options = description.options
+        self._attr_translation_key = description.key
+
+    @property
+    def current_option(self) -> str:
+        """Return the current selected option."""
+        return self.options[int(self._attribute.current_value)]
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        await self.async_set_homee_value(self.options.index(option))

homeassistant/components/homee/sensor.py

@@ -27,6 +27,8 @@ from .const import (
 from .entity import HomeeEntity, HomeeNodeEntity
 from .helpers import get_name_for_enum
 
+PARALLEL_UPDATES = 0
+
 
 def get_open_close_value(attribute: HomeeAttribute) -> str | None:
     """Return the open/close value."""
@@ -40,10 +42,22 @@ def get_window_value(attribute: HomeeAttribute) -> str | None:
     return vals.get(attribute.current_value)
 
 
+def get_brightness_device_class(
+    attribute: HomeeAttribute, device_class: SensorDeviceClass | None
+) -> SensorDeviceClass | None:
+    """Return the device class for a brightness sensor."""
+    if attribute.unit == "%":
+        return None
+    return device_class
+
+
 @dataclass(frozen=True, kw_only=True)
 class HomeeSensorEntityDescription(SensorEntityDescription):
     """A class that describes Homee sensor entities."""
 
+    device_class_fn: Callable[
+        [HomeeAttribute, SensorDeviceClass | None], SensorDeviceClass | None
+    ] = lambda attribute, device_class: device_class
     value_fn: Callable[[HomeeAttribute], str | float | None] = (
         lambda value: value.current_value
     )
@@ -67,6 +81,7 @@ SENSOR_DESCRIPTIONS: dict[AttributeType, HomeeSensorEntityDescription] = {
     AttributeType.BRIGHTNESS: HomeeSensorEntityDescription(
         key="brightness",
         device_class=SensorDeviceClass.ILLUMINANCE,
+        device_class_fn=get_brightness_device_class,
         state_class=SensorStateClass.MEASUREMENT,
         value_fn=(
             lambda attribute: attribute.current_value * 1000
@@ -303,6 +318,9 @@ class HomeeSensor(HomeeEntity, SensorEntity):
         if attribute.instance > 0:
             self._attr_translation_key = f"{self._attr_translation_key}_instance"
             self._attr_translation_placeholders = {"instance": str(attribute.instance)}
+        self._attr_device_class = description.device_class_fn(
+            attribute, description.device_class
+        )
 
     @property
     def native_value(self) -> float | str | None:

homeassistant/components/homee/strings.json

@@ -110,7 +110,20 @@
         "name": "Wake-up interval"
       }
     },
+    "select": {
+      "repeater_mode": {
+        "name": "Repeater mode",
+        "state": {
+          "off": "[%key:common::state::off%]",
+          "level1": "Level 1",
+          "level2": "Level 2"
+        }
+      }
+    },
     "sensor": {
+      "brightness": {
+        "name": "Illuminance"
+      },
       "brightness_instance": {
         "name": "Illuminance {instance}"
       },

homeassistant/components/homee/switch.py

@@ -20,6 +20,8 @@ from . import HomeeConfigEntry
 from .const import CLIMATE_PROFILES, LIGHT_PROFILES
 from .entity import HomeeEntity
 
+PARALLEL_UPDATES = 0
+
 
 def get_device_class(
     attribute: HomeeAttribute, config_entry: HomeeConfigEntry

homeassistant/components/homee/valve.py

@@ -15,6 +15,8 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import HomeeConfigEntry
 from .entity import HomeeEntity
 
+PARALLEL_UPDATES = 0
+
 VALVE_DESCRIPTIONS = {
     AttributeType.CURRENT_VALVE_POSITION: ValveEntityDescription(
         key="valve_position",

homeassistant/components/homekit/__init__.py

@@ -221,6 +221,34 @@ UNPAIR_SERVICE_SCHEMA = vol.All(
 )
 
 
+@callback
+def _async_update_entries_from_yaml(
+    hass: HomeAssistant, config: ConfigType, start_import_flow: bool
+) -> None:
+    current_entries = hass.config_entries.async_entries(DOMAIN)
+    entries_by_name, entries_by_port = _async_get_imported_entries_indices(
+        current_entries
+    )
+    hk_config: list[dict[str, Any]] = config[DOMAIN]
+
+    for index, conf in enumerate(hk_config):
+        if _async_update_config_entry_from_yaml(
+            hass, entries_by_name, entries_by_port, conf
+        ):
+            continue
+
+        if start_import_flow:
+            conf[CONF_ENTRY_INDEX] = index
+            hass.async_create_task(
+                hass.config_entries.flow.async_init(
+                    DOMAIN,
+                    context={"source": SOURCE_IMPORT},
+                    data=conf,
+                ),
+                eager_start=True,
+            )
+
+
 def _async_all_homekit_instances(hass: HomeAssistant) -> list[HomeKit]:
     """All active HomeKit instances."""
     hk_data: HomeKitEntryData | None
@@ -258,31 +286,10 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     await hass.async_add_executor_job(get_loader)
 
     _async_register_events_and_services(hass)
-
     if DOMAIN not in config:
         return True
 
-    current_entries = hass.config_entries.async_entries(DOMAIN)
-    entries_by_name, entries_by_port = _async_get_imported_entries_indices(
-        current_entries
-    )
-
-    for index, conf in enumerate(config[DOMAIN]):
-        if _async_update_config_entry_from_yaml(
-            hass, entries_by_name, entries_by_port, conf
-        ):
-            continue
-
-        conf[CONF_ENTRY_INDEX] = index
-        hass.async_create_task(
-            hass.config_entries.flow.async_init(
-                DOMAIN,
-                context={"source": SOURCE_IMPORT},
-                data=conf,
-            ),
-            eager_start=True,
-        )
-
+    _async_update_entries_from_yaml(hass, config, start_import_flow=True)
     return True
 
 
@@ -326,13 +333,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: HomeKitConfigEntry) -> b
     conf = entry.data
     options = entry.options
 
-    name = conf[CONF_NAME]
-    port = conf[CONF_PORT]
-    _LOGGER.debug("Begin setup HomeKit for %s", name)
-
+    name: str = conf[CONF_NAME]
+    port: int = conf[CONF_PORT]
     # ip_address and advertise_ip are yaml only
-    ip_address = conf.get(CONF_IP_ADDRESS, _DEFAULT_BIND)
-    advertise_ips: list[str] = conf.get(
+    ip_address: str | list[str] | None = conf.get(CONF_IP_ADDRESS, _DEFAULT_BIND)
+    advertise_ips: list[str]
+    advertise_ips = conf.get(
         CONF_ADVERTISE_IP
     ) or await network.async_get_announce_addresses(hass)
 
@@ -344,13 +350,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: HomeKitConfigEntry) -> b
     # with users who have not migrated yet we do not do exclude
     # these entities by default as we cannot migrate automatically
     # since it requires a re-pairing.
-    exclude_accessory_mode = conf.get(
+    exclude_accessory_mode: bool = conf.get(
         CONF_EXCLUDE_ACCESSORY_MODE, DEFAULT_EXCLUDE_ACCESSORY_MODE
     )
-    homekit_mode = options.get(CONF_HOMEKIT_MODE, DEFAULT_HOMEKIT_MODE)
-    entity_config = options.get(CONF_ENTITY_CONFIG, {}).copy()
-    entity_filter = FILTER_SCHEMA(options.get(CONF_FILTER, {}))
-    devices = options.get(CONF_DEVICES, [])
+    homekit_mode: str = options.get(CONF_HOMEKIT_MODE, DEFAULT_HOMEKIT_MODE)
+    entity_config: dict[str, Any] = options.get(CONF_ENTITY_CONFIG, {}).copy()
+    entity_filter: EntityFilter = FILTER_SCHEMA(options.get(CONF_FILTER, {}))
+    devices: list[str] = options.get(CONF_DEVICES, [])
 
     homekit = HomeKit(
         hass,
@@ -500,26 +506,15 @@ def _async_register_events_and_services(hass: HomeAssistant) -> None:
     async def _handle_homekit_reload(service: ServiceCall) -> None:
         """Handle start HomeKit service call."""
         config = await async_integration_yaml_config(hass, DOMAIN)
-
         if not config or DOMAIN not in config:
             return
-
-        current_entries = hass.config_entries.async_entries(DOMAIN)
-        entries_by_name, entries_by_port = _async_get_imported_entries_indices(
-            current_entries
-        )
-
-        for conf in config[DOMAIN]:
-            _async_update_config_entry_from_yaml(
-                hass, entries_by_name, entries_by_port, conf
+        _async_update_entries_from_yaml(hass, config, start_import_flow=False)
+        await asyncio.gather(
+            *(
+                create_eager_task(hass.config_entries.async_reload(entry.entry_id))
+                for entry in hass.config_entries.async_entries(DOMAIN)
             )
-
-        reload_tasks = [
-            create_eager_task(hass.config_entries.async_reload(entry.entry_id))
-            for entry in current_entries
-        ]
-
-        await asyncio.gather(*reload_tasks)
+        )
 
     async_register_admin_service(
         hass,
@@ -537,7 +532,7 @@ class HomeKit:
         hass: HomeAssistant,
         name: str,
         port: int,
-        ip_address: str | None,
+        ip_address: list[str] | str | None,
         entity_filter: EntityFilter,
         exclude_accessory_mode: bool,
         entity_config: dict[str, Any],

homeassistant/components/homekit/manifest.json

@@ -10,7 +10,7 @@
   "loggers": ["pyhap"],
   "requirements": [
     "HAP-python==4.9.2",
-    "fnv-hash-fast==1.2.6",
+    "fnv-hash-fast==1.4.0",
     "PyQRCode==1.2.1",
     "base36==0.1.1"
   ],

homeassistant/components/homematicip_cloud/strings.json

@@ -3,6 +3,7 @@
     "step": {
       "init": {
         "title": "Pick Homematic IP access point",
+        "description": "If you are about to register a **Homematic IP HCU1**, please press the button on top of the device before you continue.\n\nThe registration process must be completed within 5 minutes.",
         "data": {
           "hapid": "Access point ID (SGTIN)",
           "pin": "[%key:common::config_flow::data::pin%]",

homeassistant/components/insteon/strings.json

@@ -111,7 +111,7 @@
   },
   "services": {
     "add_all_link": {
-      "name": "Add all link",
+      "name": "Add All-Link",
       "description": "Tells the Insteon Modem (IM) start All-Linking mode. Once the IM is in All-Linking mode, press the link button on the device to complete All-Linking.",
       "fields": {
         "group": {
@@ -120,13 +120,13 @@
         },
         "mode": {
           "name": "[%key:common::config_flow::data::mode%]",
-          "description": "Linking mode   controller - IM is controller   responder - IM is responder."
+          "description": "Linking mode of the Insteon Modem."
         }
       }
     },
     "delete_all_link": {
-      "name": "Delete all link",
-      "description": "Tells the Insteon Modem (IM) to remove an All-Link record from the All-Link Database of the IM and a device. Once the IM is set to delete the link, press the link button on the corresponding device to complete the process.",
+      "name": "Delete All-Link",
+      "description": "Tells the Insteon Modem (IM) to remove an All-Link record from the All-Link database of the IM and a device. Once the IM is set to delete the link, press the link button on the corresponding device to complete the process.",
       "fields": {
         "group": {
           "name": "Group",
@@ -135,8 +135,8 @@
       }
     },
     "load_all_link_database": {
-      "name": "Load all link database",
-      "description": "Load the All-Link Database for a device. WARNING - Loading a device All-LInk database is very time consuming and inconsistent. This may take a LONG time and may need to be repeated to obtain all records.",
+      "name": "Load All-Link database",
+      "description": "Loads the All-Link database for a device. WARNING - Loading a device All-Link database is very time consuming and inconsistent. This may take a LONG time and may need to be repeated to obtain all records.",
       "fields": {
         "entity_id": {
           "name": "Entity",
@@ -149,8 +149,8 @@
       }
     },
     "print_all_link_database": {
-      "name": "Print all link database",
-      "description": "Prints the All-Link Database for a device. Requires that the All-Link Database is loaded into memory.",
+      "name": "Print All-Link database",
+      "description": "Prints the All-Link database for a device. Requires that the All-Link database is loaded into memory.",
       "fields": {
         "entity_id": {
           "name": "Entity",
@@ -159,8 +159,8 @@
       }
     },
     "print_im_all_link_database": {
-      "name": "Print IM all link database",
-      "description": "Prints the All-Link Database for the INSTEON Modem (IM)."
+      "name": "Print IM All-Link database",
+      "description": "Prints the All-Link database for the INSTEON Modem (IM)."
     },
     "x10_all_units_off": {
       "name": "X10 all units off",

homeassistant/components/iron_os/coordinator.py

@@ -8,6 +8,7 @@ from enum import Enum
 import logging
 from typing import cast
 
+from awesomeversion import AwesomeVersion
 from pynecil import (
     CharSetting,
     CommunicationError,
@@ -34,6 +35,8 @@ SCAN_INTERVAL = timedelta(seconds=5)
 SCAN_INTERVAL_GITHUB = timedelta(hours=3)
 SCAN_INTERVAL_SETTINGS = timedelta(seconds=60)
 
+V223 = AwesomeVersion("v2.23")
+
 
 @dataclass
 class IronOSCoordinators:
@@ -72,6 +75,7 @@ class IronOSBaseCoordinator[_DataT](DataUpdateCoordinator[_DataT]):
             ),
         )
         self.device = device
+        self.v223_features = False
 
     async def _async_setup(self) -> None:
         """Set up the coordinator."""
@@ -81,6 +85,8 @@ class IronOSBaseCoordinator[_DataT](DataUpdateCoordinator[_DataT]):
         except CommunicationError as e:
             raise UpdateFailed("Cannot connect to device") from e
 
+        self.v223_features = AwesomeVersion(self.device_info.build) >= V223
+
 
 class IronOSLiveDataCoordinator(IronOSBaseCoordinator[LiveDataResponse]):
     """IronOS coordinator."""

homeassistant/components/iron_os/icons.json

@@ -73,6 +73,9 @@
       },
       "power_limit": {
         "default": "mdi:flash-alert"
+      },
+      "hall_effect_sleep_time": {
+        "default": "mdi:timer-sand"
       }
     },
     "select": {
@@ -105,6 +108,9 @@
       },
       "usb_pd_mode": {
         "default": "mdi:meter-electric-outline"
+      },
+      "tip_type": {
+        "default": "mdi:pencil-outline"
       }
     },
     "sensor": {
@@ -154,7 +160,16 @@
           "soldering": "mdi:soldering-iron",
           "sleeping": "mdi:sleep",
           "settings": "mdi:menu-open",
-          "debug": "mdi:bug-play"
+          "debug": "mdi:bug-play",
+          "soldering_profile": "mdi:chart-box-outline",
+          "temperature_adjust": "mdi:thermostat-box",
+          "usb_pd_debug": "mdi:bug-play",
+          "thermal_runaway": "mdi:fire-alert",
+          "startup_logo": "mdi:dots-circle",
+          "cjc_calibration": "mdi:tune-vertical",
+          "startup_warnings": "mdi:alert",
+          "initialisation_done": "mdi:check-circle",
+          "hibernating": "mdi:sleep"
         }
       },
       "estimated_power": {

homeassistant/components/iron_os/manifest.json

@@ -14,5 +14,5 @@
   "iot_class": "local_polling",
   "loggers": ["pynecil"],
   "quality_scale": "platinum",
-  "requirements": ["pynecil==4.0.1"]
+  "requirements": ["pynecil==4.1.0"]
 }

homeassistant/components/iron_os/number.py

@@ -65,6 +65,7 @@ class PinecilNumber(StrEnum):
     VOLTAGE_DIV = "voltage_div"
     TEMP_INCREMENT_SHORT = "temp_increment_short"
     TEMP_INCREMENT_LONG = "temp_increment_long"
+    HALL_EFFECT_SLEEP_TIME = "hall_effect_sleep_time"
 
 
 def multiply(value: float | None, multiplier: float) -> float | None:
@@ -323,6 +324,23 @@ PINECIL_NUMBER_DESCRIPTIONS: tuple[IronOSNumberEntityDescription, ...] = (
     ),
 )
 
+PINECIL_NUMBER_DESCRIPTIONS_V223: tuple[IronOSNumberEntityDescription, ...] = (
+    IronOSNumberEntityDescription(
+        key=PinecilNumber.HALL_EFFECT_SLEEP_TIME,
+        translation_key=PinecilNumber.HALL_EFFECT_SLEEP_TIME,
+        value_fn=(lambda _, settings: settings.get("hall_sleep_time")),
+        characteristic=CharSetting.HALL_SLEEP_TIME,
+        raw_value_fn=lambda value: value,
+        mode=NumberMode.BOX,
+        native_min_value=0,
+        native_max_value=60,
+        native_step=5,
+        entity_category=EntityCategory.CONFIG,
+        native_unit_of_measurement=UnitOfTime.SECONDS,
+        entity_registry_enabled_default=False,
+    ),
+)
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -331,10 +349,13 @@ async def async_setup_entry(
 ) -> None:
     """Set up number entities from a config entry."""
     coordinators = entry.runtime_data
+    descriptions = PINECIL_NUMBER_DESCRIPTIONS
+
+    if coordinators.live_data.v223_features:
+        descriptions += PINECIL_NUMBER_DESCRIPTIONS_V223
 
     async_add_entities(
-        IronOSNumberEntity(coordinators, description)
-        for description in PINECIL_NUMBER_DESCRIPTIONS
+        IronOSNumberEntity(coordinators, description) for description in descriptions
     )
 
 

homeassistant/components/iron_os/select.py

@@ -17,6 +17,7 @@ from pynecil import (
     ScrollSpeed,
     SettingsDataResponse,
     TempUnit,
+    TipType,
     USBPDMode,
 )
 
@@ -53,6 +54,7 @@ class PinecilSelect(StrEnum):
     LOCKING_MODE = "locking_mode"
     LOGO_DURATION = "logo_duration"
     USB_PD_MODE = "usb_pd_mode"
+    TIP_TYPE = "tip_type"
 
 
 def enum_to_str(enum: Enum | None) -> str | None:
@@ -138,6 +140,8 @@ PINECIL_SELECT_DESCRIPTIONS: tuple[IronOSSelectEntityDescription, ...] = (
         entity_category=EntityCategory.CONFIG,
         entity_registry_enabled_default=False,
     ),
+)
+PINECIL_SELECT_DESCRIPTIONS_V222: tuple[IronOSSelectEntityDescription, ...] = (
     IronOSSelectEntityDescription(
         key=PinecilSelect.USB_PD_MODE,
         translation_key=PinecilSelect.USB_PD_MODE,
@@ -149,6 +153,27 @@ PINECIL_SELECT_DESCRIPTIONS: tuple[IronOSSelectEntityDescription, ...] = (
         entity_registry_enabled_default=False,
     ),
 )
+PINECIL_SELECT_DESCRIPTIONS_V223: tuple[IronOSSelectEntityDescription, ...] = (
+    IronOSSelectEntityDescription(
+        key=PinecilSelect.USB_PD_MODE,
+        translation_key=PinecilSelect.USB_PD_MODE,
+        characteristic=CharSetting.USB_PD_MODE,
+        value_fn=lambda x: enum_to_str(x.get("usb_pd_mode")),
+        raw_value_fn=lambda value: USBPDMode[value.upper()],
+        options=[x.name.lower() for x in USBPDMode],
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+    ),
+    IronOSSelectEntityDescription(
+        key=PinecilSelect.TIP_TYPE,
+        translation_key=PinecilSelect.TIP_TYPE,
+        characteristic=CharSetting.TIP_TYPE,
+        value_fn=lambda x: enum_to_str(x.get("tip_type")),
+        raw_value_fn=lambda value: TipType[value.upper()],
+        options=[x.name.lower() for x in TipType],
+        entity_category=EntityCategory.CONFIG,
+    ),
+)
 
 
 async def async_setup_entry(
@@ -157,11 +182,17 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up select entities from a config entry."""
-    coordinator = entry.runtime_data
+    coordinators = entry.runtime_data
+    descriptions = PINECIL_SELECT_DESCRIPTIONS
+
+    descriptions += (
+        PINECIL_SELECT_DESCRIPTIONS_V223
+        if coordinators.live_data.v223_features
+        else PINECIL_SELECT_DESCRIPTIONS_V222
+    )
 
     async_add_entities(
-        IronOSSelectEntity(coordinator, description)
-        for description in PINECIL_SELECT_DESCRIPTIONS
+        IronOSSelectEntity(coordinators, description) for description in descriptions
     )
 
 

homeassistant/components/iron_os/strings.json

@@ -94,6 +94,9 @@
       },
       "temp_increment_long": {
         "name": "Long-press temperature step"
+      },
+      "hall_effect_sleep_time": {
+        "name": "Hall sensor sleep timeout"
       }
     },
     "select": {
@@ -173,6 +176,15 @@
           "off": "[%key:common::state::off%]",
           "on": "[%key:common::state::on%]"
         }
+      },
+      "tip_type": {
+        "name": "Soldering tip type",
+        "state": {
+          "auto": "Auto sense",
+          "ts100_long": "TS100 long/Hakko T12 tip",
+          "pine_short": "Pinecil short tip",
+          "pts200": "PTS200 short tip"
+        }
       }
     },
     "sensor": {
@@ -223,7 +235,16 @@
           "sleeping": "Sleeping",
           "settings": "Settings",
           "debug": "Debug",
-          "boost": "Boost"
+          "boost": "Boost",
+          "soldering_profile": "Soldering profile",
+          "temperature_adjust": "Temperature adjust",
+          "usb_pd_debug": "USB PD debug",
+          "thermal_runaway": "Thermal runaway",
+          "startup_logo": "Booting",
+          "cjc_calibration": "CJC calibration",
+          "startup_warnings": "Startup warnings",
+          "initialisation_done": "Initialisation done",
+          "hibernating": "Hibernating"
         }
       },
       "estimated_power": {

homeassistant/components/keymitt_ble/strings.json

@@ -34,7 +34,7 @@
   "services": {
     "calibrate": {
       "name": "Calibrate",
-      "description": "Calibration - Set depth, press & hold duration, and operation mode. Warning - this will send a push command to the device.",
+      "description": "Sets the depth, press or release duration, and operation mode. Warning - this will send a push command to the device.",
       "fields": {
         "entity_id": {
           "name": "Entity",
@@ -42,15 +42,15 @@
         },
         "depth": {
           "name": "Depth",
-          "description": "Depth in percent."
+          "description": "How far to extend the push arm."
         },
         "duration": {
           "name": "Duration",
-          "description": "Duration in seconds."
+          "description": "How long to press or release."
         },
         "mode": {
           "name": "[%key:common::config_flow::data::mode%]",
-          "description": "Normal | invert | toggle."
+          "description": "The operation mode of the arm."
         }
       }
     }