Remove entity performance optimization section from copilot-instructions

Co-authored-by: Norbert Rittel <norbert@rittel.de>

.devcontainer/devcontainer.json

@@ -40,7 +40,8 @@
         "python.terminal.activateEnvInCurrentTerminal": true,
         "python.testing.pytestArgs": ["--no-cov"],
         "pylint.importStrategy": "fromEnvironment",
-        "python.analysis.typeCheckingMode": "basic",
+        // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
+        "python.analysis.typeCheckingMode": "off",
         "editor.formatOnPaste": false,
         "editor.formatOnSave": true,
         "editor.formatOnType": true,

.github/copilot-instructions.md

@@ -847,8 +847,8 @@ rules:
 ## Development Commands
 
 ### Code Quality & Linting
-- **Run all linters on all files**: `pre-commit run --all-files`
-- **Run linters on staged files only**: `pre-commit run`
+- **Run all linters on all files**: `prek run --all-files`
+- **Run linters on staged files only**: `prek run`
 - **PyLint on everything** (slow): `pylint homeassistant`
 - **PyLint on specific folder**: `pylint homeassistant/components/my_integration`
 - **MyPy type checking (whole project)**: `mypy homeassistant/`
@@ -1024,18 +1024,6 @@ class MyCoordinator(DataUpdateCoordinator[MyData]):
         )
 ```
 
-### Entity Performance Optimization
-```python
-# Use __slots__ for memory efficiency
-class MySensor(SensorEntity):
-    __slots__ = ("_attr_native_value", "_attr_available")
-    
-    @property 
-    def should_poll(self) -> bool:
-        """Disable polling when using coordinator."""
-        return False  # ✅ Let coordinator handle updates
-```
-
 ## Testing Patterns
 
 ### Testing Best Practices
@@ -1181,4 +1169,4 @@ python -m script.hassfest --integration-path homeassistant/components/my_integra
 pytest ./tests/components/my_integration \
   --cov=homeassistant.components.my_integration \
   --cov-report term-missing
-```
+```

.github/workflows/ci.yaml

@@ -59,7 +59,6 @@ env:
   # 15 is the latest version
   # - 15.2 is the latest (as of 9 Feb 2023)
   POSTGRESQL_VERSIONS: "['postgres:12.14','postgres:15.2']"
-  PRE_COMMIT_CACHE: ~/.cache/pre-commit
   UV_CACHE_DIR: /tmp/uv-cache
   APT_CACHE_BASE: /home/runner/work/apt
   APT_CACHE_DIR: /home/runner/work/apt/cache
@@ -83,7 +82,6 @@ jobs:
       integrations_glob: ${{ steps.info.outputs.integrations_glob }}
       integrations: ${{ steps.integrations.outputs.changes }}
       apt_cache_key: ${{ steps.generate_apt_cache_key.outputs.key }}
-      pre-commit_cache_key: ${{ steps.generate_pre-commit_cache_key.outputs.key }}
       python_cache_key: ${{ steps.generate_python_cache_key.outputs.key }}
       requirements: ${{ steps.core.outputs.requirements }}
       mariadb_groups: ${{ steps.info.outputs.mariadb_groups }}
@@ -111,11 +109,6 @@ jobs:
             hashFiles('requirements_all.txt') }}-${{
             hashFiles('homeassistant/package_constraints.txt') }}-${{
             hashFiles('script/gen_requirements_all.py') }}" >> $GITHUB_OUTPUT
-      - name: Generate partial pre-commit restore key
-        id: generate_pre-commit_cache_key
-        run: >-
-          echo "key=pre-commit-${{ env.CACHE_VERSION }}-${{
-            hashFiles('.pre-commit-config.yaml') }}"  >> $GITHUB_OUTPUT
       - name: Generate partial apt restore key
         id: generate_apt_cache_key
         run: |
@@ -244,8 +237,8 @@ jobs:
           echo "skip_coverage: ${skip_coverage}"
           echo "skip_coverage=${skip_coverage}" >> $GITHUB_OUTPUT
 
-  pre-commit:
-    name: Prepare pre-commit base
+  prek:
+    name: Run prek checks
     runs-on: *runs-on-ubuntu
     needs: [info]
     if: |
@@ -254,147 +247,23 @@ jobs:
       && github.event.inputs.audit-licenses-only != 'true'
     steps:
       - *checkout
-      - &setup-python-default
-        name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        id: python
-        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          check-latest: true
-      - name: Restore base Python virtual environment
-        id: cache-venv
-        uses: &actions-cache actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
-        with:
-          path: venv
-          key: &key-pre-commit-venv >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-venv-${{
-              needs.info.outputs.pre-commit_cache_key }}
-      - name: Create Python virtual environment
-        if: steps.cache-venv.outputs.cache-hit != 'true'
-        run: |
-          python -m venv venv
-          . venv/bin/activate
-          python --version
-          pip install "$(grep '^uv' < requirements.txt)"
-          uv pip install "$(cat requirements_test.txt | grep pre-commit)"
-      - name: Restore pre-commit environment from cache
-        id: cache-precommit
-        uses: *actions-cache
-        with:
-          path: ${{ env.PRE_COMMIT_CACHE }}
-          lookup-only: true
-          key: &key-pre-commit-env >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-${{
-              needs.info.outputs.pre-commit_cache_key }}
-      - name: Install pre-commit dependencies
-        if: steps.cache-precommit.outputs.cache-hit != 'true'
-        run: |
-          . venv/bin/activate
-          pre-commit install-hooks
-
-  lint-ruff-format:
-    name: Check ruff-format
-    runs-on: *runs-on-ubuntu
-    needs: &needs-pre-commit
-      - info
-      - pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - &cache-restore-pre-commit-venv
-        name: Restore base Python virtual environment
-        id: cache-venv
-        uses: &actions-cache-restore actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
-        with:
-          path: venv
-          fail-on-cache-miss: true
-          key: *key-pre-commit-venv
-      - &cache-restore-pre-commit-env
-        name: Restore pre-commit environment from cache
-        id: cache-precommit
-        uses: *actions-cache-restore
-        with:
-          path: ${{ env.PRE_COMMIT_CACHE }}
-          fail-on-cache-miss: true
-          key: *key-pre-commit-env
-      - name: Run ruff-format
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual ruff-format --all-files --show-diff-on-failure
-        env:
-          RUFF_OUTPUT_FORMAT: github
-
-  lint-ruff:
-    name: Check ruff
-    runs-on: *runs-on-ubuntu
-    needs: *needs-pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - *cache-restore-pre-commit-venv
-      - *cache-restore-pre-commit-env
-      - name: Run ruff
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual ruff-check --all-files --show-diff-on-failure
-        env:
-          RUFF_OUTPUT_FORMAT: github
-
-  lint-other:
-    name: Check other linters
-    runs-on: *runs-on-ubuntu
-    needs: *needs-pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - *cache-restore-pre-commit-venv
-      - *cache-restore-pre-commit-env
-
       - name: Register yamllint problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/yamllint.json"
-      - name: Run yamllint
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual yamllint --all-files --show-diff-on-failure
-
       - name: Register check-json problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/check-json.json"
-      - name: Run check-json
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual check-json --all-files --show-diff-on-failure
-
-      - name: Run prettier (fully)
-        if: needs.info.outputs.test_full_suite == 'true'
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual prettier --all-files --show-diff-on-failure
-
-      - name: Run prettier (partially)
-        if: needs.info.outputs.test_full_suite == 'false'
-        shell: bash
-        run: |
-          . venv/bin/activate
-          shopt -s globstar
-          pre-commit run --hook-stage manual prettier --show-diff-on-failure --files {homeassistant,tests}/components/${{ needs.info.outputs.integrations_glob }}/{*,**/*}
-
       - name: Register check executables problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/check-executables-have-shebangs.json"
-      - name: Run executables check
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual check-executables-have-shebangs --all-files --show-diff-on-failure
-
       - name: Register codespell problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/codespell.json"
-      - name: Run codespell
-        run: |
-          . venv/bin/activate
-          pre-commit run --show-diff-on-failure --hook-stage manual codespell --all-files
+      - name: Run prek
+        uses: j178/prek-action@9d6a3097e0c1865ecce00cfb89fe80f2ee91b547 # v1.0.12
+        env:
+          PREK_SKIP: no-commit-to-branch,mypy,pylint,gen_requirements_all,hassfest,hassfest-metadata,hassfest-mypy-config
+          RUFF_OUTPUT_FORMAT: github
 
   lint-hadolint:
     name: Check ${{ matrix.file }}
@@ -434,7 +303,7 @@ jobs:
       - &setup-python-matrix
         name: Set up Python ${{ matrix.python-version }}
         id: python
-        uses: *actions-setup-python
+        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: ${{ matrix.python-version }}
           check-latest: true
@@ -447,7 +316,7 @@ jobs:
             env.HA_SHORT_VERSION }}-$(date -u '+%Y-%m-%dT%H:%M:%s')" >> $GITHUB_OUTPUT
       - name: Restore base Python virtual environment
         id: cache-venv
-        uses: *actions-cache
+        uses: &actions-cache actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
         with:
           path: venv
           key: &key-python-venv >-
@@ -562,7 +431,7 @@ jobs:
     steps:
       - &cache-restore-apt
         name: Restore apt cache
-        uses: *actions-cache-restore
+        uses: &actions-cache-restore actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
         with:
           path: *path-apt-cache
           fail-on-cache-miss: true
@@ -579,7 +448,13 @@ jobs:
             -o Dir::State::Lists=${{ env.APT_LIST_CACHE_DIR }} \
             libturbojpeg
       - *checkout
-      - *setup-python-default
+      - &setup-python-default
+        name: Set up Python ${{ env.DEFAULT_PYTHON }}
+        id: python
+        uses: *actions-setup-python
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          check-latest: true
       - &cache-restore-python-default
         name: Restore full Python ${{ env.DEFAULT_PYTHON }} virtual environment
         id: cache-venv
@@ -782,9 +657,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     steps:
       - *cache-restore-apt
@@ -823,9 +696,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
       - prepare-pytest-full
     if: |
@@ -949,9 +820,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'
@@ -1066,9 +935,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'
@@ -1202,9 +1069,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
+        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
+        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           category: "/language:python"

.pre-commit-config.yaml

@@ -39,14 +39,14 @@ repos:
       - id: prettier
         additional_dependencies:
           - prettier@3.6.2
-          - prettier-plugin-sort-json@4.1.1
+          - prettier-plugin-sort-json@4.2.0
   - repo: https://github.com/cdce8p/python-typing-update
     rev: v0.6.0
     hooks:
       # Run `python-typing-update` hook manually from time to time
       # to update python typing syntax.
       # Will require manual work, before submitting changes!
-      # pre-commit run --hook-stage manual python-typing-update --all-files
+      # prek run --hook-stage manual python-typing-update --all-files
       - id: python-typing-update
         stages: [manual]
         args:

.strict-typing

@@ -407,6 +407,7 @@ homeassistant.components.person.*
 homeassistant.components.pi_hole.*
 homeassistant.components.ping.*
 homeassistant.components.plugwise.*
+homeassistant.components.pooldose.*
 homeassistant.components.portainer.*
 homeassistant.components.powerfox.*
 homeassistant.components.powerwall.*

.vscode/settings.default.jsonc

@@ -7,8 +7,8 @@
   "python.testing.pytestEnabled": false,
   // https://code.visualstudio.com/docs/python/linting#_general-settings
   "pylint.importStrategy": "fromEnvironment",
-  // Pyright is too pedantic for Home Assistant
-  "python.analysis.typeCheckingMode": "basic",
+  // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
+  "python.analysis.typeCheckingMode": "off",
   "[python]": {
     "editor.defaultFormatter": "charliermarsh.ruff",
   },

.vscode/tasks.json

@@ -45,7 +45,7 @@
     {
       "label": "Ruff",
       "type": "shell",
-      "command": "pre-commit run ruff-check --all-files",
+      "command": "prek run ruff-check --all-files",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -57,9 +57,9 @@
       "problemMatcher": []
     },
     {
-      "label": "Pre-commit",
+      "label": "Prek",
       "type": "shell",
-      "command": "pre-commit run --show-diff-on-failure",
+      "command": "prek run --show-diff-on-failure",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -120,7 +120,7 @@
     {
       "label": "Generate Requirements",
       "type": "shell",
-      "command": "./script/gen_requirements_all.py",
+      "command": "${command:python.interpreterPath} -m script.gen_requirements_all",
       "group": {
         "kind": "build",
         "isDefault": true

CODEOWNERS

@@ -661,6 +661,8 @@ build.json @home-assistant/supervisor
 /tests/components/harmony/ @ehendrix23 @bdraco @mkeesey @Aohzan
 /homeassistant/components/hassio/ @home-assistant/supervisor
 /tests/components/hassio/ @home-assistant/supervisor
+/homeassistant/components/hdfury/ @glenndehaan
+/tests/components/hdfury/ @glenndehaan
 /homeassistant/components/hdmi_cec/ @inytar
 /tests/components/hdmi_cec/ @inytar
 /homeassistant/components/heatmiser/ @andylockran
@@ -1066,6 +1068,8 @@ build.json @home-assistant/supervisor
 /tests/components/myuplink/ @pajzo @astrandb
 /homeassistant/components/nam/ @bieniu
 /tests/components/nam/ @bieniu
+/homeassistant/components/namecheapdns/ @tr4nt0r
+/tests/components/namecheapdns/ @tr4nt0r
 /homeassistant/components/nanoleaf/ @milanmeu @joostlek
 /tests/components/nanoleaf/ @milanmeu @joostlek
 /homeassistant/components/nasweb/ @nasWebio
@@ -1170,8 +1174,8 @@ build.json @home-assistant/supervisor
 /tests/components/open_router/ @joostlek
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
-/homeassistant/components/openevse/ @c00w
-/tests/components/openevse/ @c00w
+/homeassistant/components/openevse/ @c00w @firstof9
+/tests/components/openevse/ @c00w @firstof9
 /homeassistant/components/openexchangerates/ @MartinHjelmare
 /tests/components/openexchangerates/ @MartinHjelmare
 /homeassistant/components/opengarage/ @danielhiversen

homeassistant/components/airobot/button.py

@@ -43,6 +43,13 @@ BUTTON_TYPES: tuple[AirobotButtonEntityDescription, ...] = (
         entity_category=EntityCategory.CONFIG,
         press_fn=lambda coordinator: coordinator.client.reboot_thermostat(),
     ),
+    AirobotButtonEntityDescription(
+        key="recalibrate_co2",
+        translation_key="recalibrate_co2",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        press_fn=lambda coordinator: coordinator.client.recalibrate_co2_sensor(),
+    ),
 )
 
 

homeassistant/components/airobot/icons.json

@@ -1,5 +1,10 @@
 {
   "entity": {
+    "button": {
+      "recalibrate_co2": {
+        "default": "mdi:molecule-co2"
+      }
+    },
     "number": {
       "hysteresis_band": {
         "default": "mdi:delta"

homeassistant/components/airobot/manifest.json

@@ -12,6 +12,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pyairobotrest"],
-  "quality_scale": "silver",
+  "quality_scale": "gold",
   "requirements": ["pyairobotrest==0.2.0"]
 }

homeassistant/components/airobot/quality_scale.yaml

@@ -43,7 +43,7 @@ rules:
   discovery-update-info: done
   discovery: done
   docs-data-update: done
-  docs-examples: todo
+  docs-examples: done
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done

homeassistant/components/airobot/strings.json

@@ -59,6 +59,11 @@
     }
   },
   "entity": {
+    "button": {
+      "recalibrate_co2": {
+        "name": "Recalibrate CO2 sensor"
+      }
+    },
     "number": {
       "hysteresis_band": {
         "name": "Hysteresis band"

homeassistant/components/airzone/entity.py

@@ -85,6 +85,22 @@ class AirzoneSystemEntity(AirzoneEntity):
                 value = system[key]
         return value
 
+    async def _async_update_sys_params(self, params: dict[str, Any]) -> None:
+        """Send system parameters to API."""
+        _params = {
+            API_SYSTEM_ID: self.system_id,
+            **params,
+        }
+        _LOGGER.debug("update_sys_params=%s", _params)
+        try:
+            await self.coordinator.airzone.set_sys_parameters(_params)
+        except AirzoneError as error:
+            raise HomeAssistantError(
+                f"Failed to set system {self.entity_id}: {error}"
+            ) from error
+
+        self.coordinator.async_set_updated_data(self.coordinator.airzone.data())
+
 
 class AirzoneHotWaterEntity(AirzoneEntity):
     """Define an Airzone Hot Water entity."""

homeassistant/components/airzone/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==1.0.4"]
+  "requirements": ["aioairzone==1.0.5"]
 }

homeassistant/components/airzone/select.py

@@ -20,6 +20,7 @@ from aioairzone.const import (
     AZD_MODES,
     AZD_Q_ADAPT,
     AZD_SLEEP,
+    AZD_SYSTEMS,
     AZD_ZONES,
 )
 
@@ -30,7 +31,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AirzoneConfigEntry, AirzoneUpdateCoordinator
-from .entity import AirzoneEntity, AirzoneZoneEntity
+from .entity import AirzoneEntity, AirzoneSystemEntity, AirzoneZoneEntity
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -85,14 +86,7 @@ def main_zone_options(
     return [k for k, v in options.items() if v in modes]
 
 
-MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
-    AirzoneSelectDescription(
-        api_param=API_MODE,
-        key=AZD_MODE,
-        options_dict=MODE_DICT,
-        options_fn=main_zone_options,
-        translation_key="modes",
-    ),
+SYSTEM_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
     AirzoneSelectDescription(
         api_param=API_Q_ADAPT,
         entity_category=EntityCategory.CONFIG,
@@ -104,6 +98,17 @@ MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
 )
 
 
+MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
+    AirzoneSelectDescription(
+        api_param=API_MODE,
+        key=AZD_MODE,
+        options_dict=MODE_DICT,
+        options_fn=main_zone_options,
+        translation_key="modes",
+    ),
+)
+
+
 ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
     AirzoneSelectDescription(
         api_param=API_COLD_ANGLE,
@@ -140,16 +145,37 @@ async def async_setup_entry(
     """Add Airzone select from a config_entry."""
     coordinator = entry.runtime_data
 
+    added_systems: set[str] = set()
     added_zones: set[str] = set()
 
     def _async_entity_listener() -> None:
         """Handle additions of select."""
 
+        entities: list[AirzoneBaseSelect] = []
+
+        systems_data = coordinator.data.get(AZD_SYSTEMS, {})
+        received_systems = set(systems_data)
+        new_systems = received_systems - added_systems
+        if new_systems:
+            entities.extend(
+                AirzoneSystemSelect(
+                    coordinator,
+                    description,
+                    entry,
+                    system_id,
+                    systems_data.get(system_id),
+                )
+                for system_id in new_systems
+                for description in SYSTEM_SELECT_TYPES
+                if description.key in systems_data.get(system_id)
+            )
+            added_systems.update(new_systems)
+
         zones_data = coordinator.data.get(AZD_ZONES, {})
         received_zones = set(zones_data)
         new_zones = received_zones - added_zones
         if new_zones:
-            entities: list[AirzoneZoneSelect] = [
+            entities.extend(
                 AirzoneZoneSelect(
                     coordinator,
                     description,
@@ -161,8 +187,8 @@ async def async_setup_entry(
                 for description in MAIN_ZONE_SELECT_TYPES
                 if description.key in zones_data.get(system_zone_id)
                 and zones_data.get(system_zone_id).get(AZD_MASTER) is True
-            ]
-            entities += [
+            )
+            entities.extend(
                 AirzoneZoneSelect(
                     coordinator,
                     description,
@@ -173,10 +199,11 @@ async def async_setup_entry(
                 for system_zone_id in new_zones
                 for description in ZONE_SELECT_TYPES
                 if description.key in zones_data.get(system_zone_id)
-            ]
-            async_add_entities(entities)
+            )
             added_zones.update(new_zones)
 
+        async_add_entities(entities)
+
     entry.async_on_unload(coordinator.async_add_listener(_async_entity_listener))
     _async_entity_listener()
 
@@ -203,6 +230,38 @@ class AirzoneBaseSelect(AirzoneEntity, SelectEntity):
         self._attr_current_option = self._get_current_option()
 
 
+class AirzoneSystemSelect(AirzoneSystemEntity, AirzoneBaseSelect):
+    """Define an Airzone System select."""
+
+    def __init__(
+        self,
+        coordinator: AirzoneUpdateCoordinator,
+        description: AirzoneSelectDescription,
+        entry: ConfigEntry,
+        system_id: str,
+        system_data: dict[str, Any],
+    ) -> None:
+        """Initialize."""
+        super().__init__(coordinator, entry, system_data)
+
+        self._attr_unique_id = f"{self._attr_unique_id}_{system_id}_{description.key}"
+        self.entity_description = description
+
+        self._attr_options = self.entity_description.options_fn(
+            system_data, description.options_dict
+        )
+
+        self.values_dict = {v: k for k, v in description.options_dict.items()}
+
+        self._async_update_attrs()
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        param = self.entity_description.api_param
+        value = self.entity_description.options_dict[option]
+        await self._async_update_sys_params({param: value})
+
+
 class AirzoneZoneSelect(AirzoneZoneEntity, AirzoneBaseSelect):
     """Define an Airzone Zone select."""
 

homeassistant/components/anthropic/entity.py

@@ -69,6 +69,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, llm
 from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.json import json_dumps
 from homeassistant.util import slugify
 
 from . import AnthropicConfigEntry
@@ -193,7 +194,7 @@ def _convert_content(
                 tool_result_block = ToolResultBlockParam(
                     type="tool_result",
                     tool_use_id=content.tool_call_id,
-                    content=json.dumps(content.tool_result),
+                    content=json_dumps(content.tool_result),
                 )
                 external_tool = False
             if not messages or messages[-1]["role"] != (

homeassistant/components/apcupsd/sensor.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import logging
 
+import dateutil
+
 from homeassistant.components.automation import automations_with_entity
 from homeassistant.components.script import scripts_with_entity
 from homeassistant.components.sensor import (
@@ -179,6 +181,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     LAST_S_TEST: SensorEntityDescription(
         key=LAST_S_TEST,
         translation_key="last_self_test",
+        device_class=SensorDeviceClass.TIMESTAMP,
     ),
     "lastxfer": SensorEntityDescription(
         key="lastxfer",
@@ -232,6 +235,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "masterupd": SensorEntityDescription(
         key="masterupd",
         translation_key="master_update",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "maxlinev": SensorEntityDescription(
@@ -365,6 +369,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "starttime": SensorEntityDescription(
         key="starttime",
         translation_key="startup_time",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "statflag": SensorEntityDescription(
@@ -416,16 +421,19 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "xoffbat": SensorEntityDescription(
         key="xoffbat",
         translation_key="transfer_from_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xoffbatt": SensorEntityDescription(
         key="xoffbatt",
         translation_key="transfer_from_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xonbatt": SensorEntityDescription(
         key="xonbatt",
         translation_key="transfer_to_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
 }
@@ -529,7 +537,13 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
             self._attr_native_value = None
             return
 
-        self._attr_native_value, inferred_unit = infer_unit(self.coordinator.data[key])
+        data = self.coordinator.data[key]
+
+        if self.entity_description.device_class == SensorDeviceClass.TIMESTAMP:
+            self._attr_native_value = dateutil.parser.parse(data)
+            return
+
+        self._attr_native_value, inferred_unit = infer_unit(data)
         if not self.native_unit_of_measurement:
             self._attr_native_unit_of_measurement = inferred_unit
 

homeassistant/components/assist_pipeline/audio_enhancer.py

@@ -3,9 +3,8 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 import logging
-import math
 
-from pysilero_vad import SileroVoiceActivityDetector
+from pymicro_vad import MicroVad
 from pyspeex_noise import AudioProcessor
 
 from .const import BYTES_PER_CHUNK
@@ -43,8 +42,8 @@ class AudioEnhancer(ABC):
         """Enhance chunk of PCM audio @ 16Khz with 16-bit mono samples."""
 
 
-class SileroVadSpeexEnhancer(AudioEnhancer):
-    """Audio enhancer that runs Silero VAD and speex."""
+class MicroVadSpeexEnhancer(AudioEnhancer):
+    """Audio enhancer that runs microVAD and speex."""
 
     def __init__(
         self, auto_gain: int, noise_suppression: int, is_vad_enabled: bool
@@ -70,49 +69,21 @@ class SileroVadSpeexEnhancer(AudioEnhancer):
                 self.noise_suppression,
             )
 
-        self.vad: SileroVoiceActivityDetector | None = None
-
-        # We get 10ms chunks but Silero works on 32ms chunks, so we have to
-        # buffer audio. The previous speech probability is used until enough
-        # audio has been buffered.
-        self._vad_buffer: bytearray | None = None
-        self._vad_buffer_chunks = 0
-        self._vad_buffer_chunk_idx = 0
-        self._last_speech_probability: float | None = None
+        self.vad: MicroVad | None = None
 
         if self.is_vad_enabled:
-            self.vad = SileroVoiceActivityDetector()
-
-            # VAD buffer is a multiple of 10ms, but Silero VAD needs 32ms.
-            self._vad_buffer_chunks = int(
-                math.ceil(self.vad.chunk_bytes() / BYTES_PER_CHUNK)
-            )
-            self._vad_leftover_bytes = self.vad.chunk_bytes() - BYTES_PER_CHUNK
-            self._vad_buffer = bytearray(self.vad.chunk_bytes())
-            _LOGGER.debug("Initialized Silero VAD")
+            self.vad = MicroVad()
+            _LOGGER.debug("Initialized microVAD")
 
     def enhance_chunk(self, audio: bytes, timestamp_ms: int) -> EnhancedAudioChunk:
         """Enhance 10ms chunk of PCM audio @ 16Khz with 16-bit mono samples."""
+        speech_probability: float | None = None
+
         assert len(audio) == BYTES_PER_CHUNK
 
         if self.vad is not None:
             # Run VAD
-            assert self._vad_buffer is not None
-            start_idx = self._vad_buffer_chunk_idx * BYTES_PER_CHUNK
-            self._vad_buffer[start_idx : start_idx + BYTES_PER_CHUNK] = audio
-
-            self._vad_buffer_chunk_idx += 1
-            if self._vad_buffer_chunk_idx >= self._vad_buffer_chunks:
-                # We have enough data to run Silero VAD (32 ms)
-                self._last_speech_probability = self.vad.process_chunk(
-                    self._vad_buffer[: self.vad.chunk_bytes()]
-                )
-
-                # Copy leftover audio that wasn't processed to start
-                self._vad_buffer[: self._vad_leftover_bytes] = self._vad_buffer[
-                    -self._vad_leftover_bytes :
-                ]
-                self._vad_buffer_chunk_idx = 0
+            speech_probability = self.vad.Process10ms(audio)
 
         if self.audio_processor is not None:
             # Run noise suppression and auto gain
@@ -121,5 +92,5 @@ class SileroVadSpeexEnhancer(AudioEnhancer):
         return EnhancedAudioChunk(
             audio=audio,
             timestamp_ms=timestamp_ms,
-            speech_probability=self._last_speech_probability,
+            speech_probability=speech_probability,
         )

homeassistant/components/assist_pipeline/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "system",
   "iot_class": "local_push",
   "quality_scale": "internal",
-  "requirements": ["pysilero-vad==3.0.1", "pyspeex-noise==1.0.2"]
+  "requirements": ["pymicro-vad==1.0.1", "pyspeex-noise==1.0.2"]
 }

homeassistant/components/assist_pipeline/pipeline.py

@@ -55,7 +55,7 @@ from homeassistant.util import (
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.limited_size_dict import LimitedSizeDict
 
-from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, SileroVadSpeexEnhancer
+from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, MicroVadSpeexEnhancer
 from .const import (
     ACKNOWLEDGE_PATH,
     BYTES_PER_CHUNK,
@@ -633,7 +633,7 @@ class PipelineRun:
         # Initialize with audio settings
         if self.audio_settings.needs_processor and (self.audio_enhancer is None):
             # Default audio enhancer
-            self.audio_enhancer = SileroVadSpeexEnhancer(
+            self.audio_enhancer = MicroVadSpeexEnhancer(
                 self.audio_settings.auto_gain_dbfs,
                 self.audio_settings.noise_suppression_level,
                 self.audio_settings.is_vad_enabled,

homeassistant/components/automation/__init__.py

@@ -123,6 +123,7 @@ SERVICE_TRIGGER = "trigger"
 NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG = "new_triggers_conditions"
 
 _EXPERIMENTAL_CONDITION_PLATFORMS = {
+    "fan",
     "light",
 }
 

homeassistant/components/azure_service_bus/notify.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import logging
+from typing import Any
 
 from azure.servicebus import ServiceBusMessage
 from azure.servicebus.aio import ServiceBusClient, ServiceBusSender
@@ -92,7 +93,7 @@ class ServiceBusNotificationService(BaseNotificationService):
         """Initialize the service."""
         self._client = client
 
-    async def async_send_message(self, message, **kwargs):
+    async def async_send_message(self, message: str, **kwargs: Any) -> None:
         """Send a message."""
         dto = {ATTR_ASB_MESSAGE: message}
 

homeassistant/components/backblaze_b2/backup.py

@@ -36,6 +36,10 @@ _LOGGER = logging.getLogger(__name__)
 # Cache TTL for backup list (in seconds)
 CACHE_TTL = 300
 
+# Timeout for upload operations (in seconds)
+# This prevents uploads from hanging indefinitely
+UPLOAD_TIMEOUT = 43200  # 12 hours (matches B2 HTTP timeout)
+
 
 def suggested_filenames(backup: AgentBackup) -> tuple[str, str]:
     """Return the suggested filenames for the backup and metadata files."""
@@ -329,13 +333,28 @@ class BackblazeBackupAgent(BackupAgent):
         _LOGGER.debug("Uploading backup file %s with streaming", filename)
         try:
             content_type, _ = mimetypes.guess_type(filename)
-            file_version = await self._hass.async_add_executor_job(
-                self._upload_unbound_stream_sync,
-                reader,
-                filename,
-                content_type or "application/x-tar",
-                file_info,
+            file_version = await asyncio.wait_for(
+                self._hass.async_add_executor_job(
+                    self._upload_unbound_stream_sync,
+                    reader,
+                    filename,
+                    content_type or "application/x-tar",
+                    file_info,
+                ),
+                timeout=UPLOAD_TIMEOUT,
             )
+        except TimeoutError:
+            _LOGGER.error(
+                "Upload of %s timed out after %s seconds", filename, UPLOAD_TIMEOUT
+            )
+            reader.abort()
+            raise BackupAgentError(
+                f"Upload timed out after {UPLOAD_TIMEOUT} seconds"
+            ) from None
+        except asyncio.CancelledError:
+            _LOGGER.warning("Upload of %s was cancelled", filename)
+            reader.abort()
+            raise
         finally:
             reader.close()
 

homeassistant/components/bang_olufsen/__init__.py

@@ -34,7 +34,12 @@ class BeoData:
 
 type BeoConfigEntry = ConfigEntry[BeoData]
 
-PLATFORMS = [Platform.EVENT, Platform.MEDIA_PLAYER]
+PLATFORMS = [
+    Platform.BINARY_SENSOR,
+    Platform.EVENT,
+    Platform.MEDIA_PLAYER,
+    Platform.SENSOR,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:

homeassistant/components/bang_olufsen/binary_sensor.py

@@ -0,0 +1,63 @@
+"""Binary Sensor entities for the Bang & Olufsen integration."""
+
+from __future__ import annotations
+
+from mozart_api.models import BatteryState
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BeoConfigEntry
+from .const import CONNECTION_STATUS, DOMAIN, WebsocketNotification
+from .entity import BeoEntity
+from .util import supports_battery
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BeoConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Binary Sensor entities from config entry."""
+    if await supports_battery(config_entry.runtime_data.client):
+        async_add_entities(new_entities=[BeoBinarySensorBatteryCharging(config_entry)])
+
+
+class BeoBinarySensorBatteryCharging(BinarySensorEntity, BeoEntity):
+    """Battery charging Binary Sensor."""
+
+    _attr_device_class = BinarySensorDeviceClass.BATTERY_CHARGING
+    _attr_is_on = False
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Init the battery charging Binary Sensor."""
+        super().__init__(config_entry, config_entry.runtime_data.client)
+
+        self._attr_unique_id = f"{self._unique_id}_charging"
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+                self._update_battery_charging,
+            )
+        )
+
+    async def _update_battery_charging(self, data: BatteryState) -> None:
+        """Update battery charging."""
+        self._attr_is_on = bool(data.is_charging)
+        self.async_write_ha_state()

homeassistant/components/bang_olufsen/const.py

@@ -115,6 +115,7 @@ class WebsocketNotification(StrEnum):
     """Enum for WebSocket notification types."""
 
     ACTIVE_LISTENING_MODE = "active_listening_mode"
+    BATTERY = "battery"
     BEO_REMOTE_BUTTON = "beo_remote_button"
     BUTTON = "button"
     PLAYBACK_ERROR = "playback_error"

homeassistant/components/bang_olufsen/diagnostics.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
 from homeassistant.components.event import DOMAIN as EVENT_DOMAIN
 from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
@@ -55,6 +57,19 @@ async def async_get_config_entry_diagnostics(
 
     # Get remotes
     for remote in await get_remotes(config_entry.runtime_data.client):
+        # Get Battery Sensor states
+        if entity_id := entity_registry.async_get_entity_id(
+            SENSOR_DOMAIN,
+            DOMAIN,
+            f"{remote.serial_number}_{config_entry.unique_id}_remote_battery_level",
+        ):
+            if state := hass.states.get(entity_id):
+                state_dict = dict(state.as_dict())
+
+                # Remove context as it is not relevant
+                state_dict.pop("context")
+                data[f"remote_{remote.serial_number}_battery_level"] = state_dict
+
         # Get key Event entity states (if enabled)
         for key_type in get_remote_keys():
             if entity_id := entity_registry.async_get_entity_id(
@@ -72,4 +87,26 @@ async def async_get_config_entry_diagnostics(
         # Add remote Mozart model
         data[f"remote_{remote.serial_number}"] = dict(remote)
 
+    # Get Mozart battery entity
+    if entity_id := entity_registry.async_get_entity_id(
+        SENSOR_DOMAIN, DOMAIN, f"{config_entry.unique_id}_battery_level"
+    ):
+        if state := hass.states.get(entity_id):
+            state_dict = dict(state.as_dict())
+
+            # Remove context as it is not relevant
+            state_dict.pop("context")
+            data["battery_level"] = state_dict
+
+    # Get Mozart battery charging entity
+    if entity_id := entity_registry.async_get_entity_id(
+        BINARY_SENSOR_DOMAIN, DOMAIN, f"{config_entry.unique_id}_charging"
+    ):
+        if state := hass.states.get(entity_id):
+            state_dict = dict(state.as_dict())
+
+            # Remove context as it is not relevant
+            state_dict.pop("context")
+            data["charging"] = state_dict
+
     return data

homeassistant/components/bang_olufsen/sensor.py

@@ -0,0 +1,139 @@
+"""Sensor entities for the Bang & Olufsen integration."""
+
+from __future__ import annotations
+
+import contextlib
+from datetime import timedelta
+
+from aiohttp import ClientConnectorError
+from mozart_api.exceptions import ApiException
+from mozart_api.models import BatteryState, PairedRemote
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorStateClass,
+)
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BeoConfigEntry
+from .const import CONNECTION_STATUS, DOMAIN, WebsocketNotification
+from .entity import BeoEntity
+from .util import get_remotes, supports_battery
+
+SCAN_INTERVAL = timedelta(minutes=15)
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BeoConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Sensor entities from config entry."""
+    entities: list[BeoSensor] = []
+
+    # Check for Mozart device with battery
+    if await supports_battery(config_entry.runtime_data.client):
+        entities.append(BeoSensorBatteryLevel(config_entry))
+
+    # Add any Beoremote One remotes
+    entities.extend(
+        [
+            BeoSensorRemoteBatteryLevel(config_entry, remote)
+            for remote in (await get_remotes(config_entry.runtime_data.client))
+        ]
+    )
+
+    async_add_entities(entities, update_before_add=True)
+
+
+class BeoSensor(SensorEntity, BeoEntity):
+    """Base Bang & Olufsen Sensor."""
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Initialize Sensor."""
+        super().__init__(config_entry, config_entry.runtime_data.client)
+
+
+class BeoSensorBatteryLevel(BeoSensor):
+    """Battery level Sensor for Mozart devices."""
+
+    _attr_device_class = SensorDeviceClass.BATTERY
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_state_class = SensorStateClass.MEASUREMENT
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Init the battery level Sensor."""
+        super().__init__(config_entry)
+
+        self._attr_unique_id = f"{self._unique_id}_battery_level"
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+                self._update_battery,
+            )
+        )
+
+    async def _update_battery(self, data: BatteryState) -> None:
+        """Update sensor value."""
+        self._attr_native_value = data.battery_level
+        self.async_write_ha_state()
+
+
+class BeoSensorRemoteBatteryLevel(BeoSensor):
+    """Battery level Sensor for the Beoremote One."""
+
+    _attr_device_class = SensorDeviceClass.BATTERY
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_should_poll = True
+    _attr_state_class = SensorStateClass.MEASUREMENT
+
+    def __init__(self, config_entry: BeoConfigEntry, remote: PairedRemote) -> None:
+        """Init the battery level Sensor."""
+        super().__init__(config_entry)
+        # Serial number is not None, as the remote object is provided by get_remotes
+        assert remote.serial_number
+
+        self._attr_unique_id = (
+            f"{remote.serial_number}_{self._unique_id}_remote_battery_level"
+        )
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, f"{remote.serial_number}_{self._unique_id}")}
+        )
+        self._attr_native_value = remote.battery_level
+        self._remote = remote
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+
+    async def async_update(self) -> None:
+        """Poll battery status."""
+        with contextlib.suppress(ApiException, ClientConnectorError, TimeoutError):
+            for remote in await get_remotes(self._client):
+                if remote.serial_number == self._remote.serial_number:
+                    self._attr_native_value = remote.battery_level
+                    break

homeassistant/components/bang_olufsen/util.py

@@ -84,3 +84,10 @@ def get_remote_keys() -> list[str]:
             for key_type in (*BEO_REMOTE_KEYS, *BEO_REMOTE_CONTROL_KEYS)
         ],
     ]
+
+
+async def supports_battery(client: MozartClient) -> bool:
+    """Get if a Mozart device has a battery."""
+    battery_state = await client.get_battery_state()
+
+    return battery_state.state != "BatteryNotPresent"

homeassistant/components/bang_olufsen/websocket.py

@@ -6,6 +6,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from mozart_api.models import (
+    BatteryState,
     BeoRemoteButton,
     ButtonEvent,
     ListeningModeProps,
@@ -60,6 +61,7 @@ class BeoWebsocket(BeoBase):
         self._client.get_active_listening_mode_notifications(
             self.on_active_listening_mode
         )
+        self._client.get_battery_notifications(self.on_battery_notification)
         self._client.get_beo_remote_button_notifications(
             self.on_beo_remote_button_notification
         )
@@ -115,6 +117,14 @@ class BeoWebsocket(BeoBase):
             notification,
         )
 
+    def on_battery_notification(self, notification: BatteryState) -> None:
+        """Send battery dispatch."""
+        async_dispatcher_send(
+            self.hass,
+            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+            notification,
+        )
+
     def on_beo_remote_button_notification(self, notification: BeoRemoteButton) -> None:
         """Send beo_remote_button dispatch."""
         if TYPE_CHECKING:

homeassistant/components/braviatv/coordinator.py

@@ -22,7 +22,7 @@ from homeassistant.components.media_player import MediaType
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_CLIENT_ID, CONF_PIN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -56,8 +56,31 @@ def catch_braviatv_errors[_BraviaTVCoordinatorT: BraviaTVCoordinator, **_P](
         """Catch Bravia errors and log message."""
         try:
             await func(self, *args, **kwargs)
+        except BraviaNotFound as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error_not_found",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
+        except (BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error_offline",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
         except BraviaError as err:
-            _LOGGER.error("Command error: %s", err)
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                    "error": repr(err),
+                },
+            ) from err
         await self.async_request_refresh()
 
     return wrapper
@@ -165,17 +188,35 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
             if self.skipped_updates < 10:
                 self.connected = False
                 self.skipped_updates += 1
-                _LOGGER.debug("Update skipped, Bravia API service is reloading")
+                _LOGGER.debug(
+                    "Update for %s skipped: the Bravia API service is reloading",
+                    self.config_entry.title,
+                )
                 return
-            raise UpdateFailed("Error communicating with device") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error_not_found",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
         except (BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff):
             self.is_on = False
             self.connected = False
-            _LOGGER.debug("Update skipped, Bravia TV is off")
+            _LOGGER.debug(
+                "Update for %s skipped: the TV is turned off", self.config_entry.title
+            )
         except BraviaError as err:
             self.is_on = False
             self.connected = False
-            raise UpdateFailed("Error communicating with device") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                    "error": repr(err),
+                },
+            ) from err
 
     async def async_update_volume(self) -> None:
         """Update volume information."""

homeassistant/components/braviatv/strings.json

@@ -55,5 +55,22 @@
         "name": "Terminate apps"
       }
     }
+  },
+  "exceptions": {
+    "command_error": {
+      "message": "Error sending command to {device}: {error}"
+    },
+    "command_error_not_found": {
+      "message": "Error sending command to {device}: the Bravia API service is reloading"
+    },
+    "command_error_offline": {
+      "message": "Error sending command to {device}: the TV is turned off"
+    },
+    "update_error": {
+      "message": "Error updating data for {device}: {error}"
+    },
+    "update_error_not_found": {
+      "message": "Error updating data for {device}: the Bravia API service is stuck"
+    }
   }
 }

homeassistant/components/bsblan/__init__.py

@@ -1,5 +1,6 @@
 """The BSB-Lan integration."""
 
+import asyncio
 import dataclasses
 
 from bsblan import (
@@ -77,12 +78,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
     bsblan = BSBLAN(config, session)
 
     try:
-        # Initialize the client first - this sets up internal caches and validates the connection
+        # Initialize the client first - this sets up internal caches and validates
+        # the connection by fetching firmware version
         await bsblan.initialize()
-        # Fetch all required device metadata
-        device = await bsblan.device()
-        info = await bsblan.info()
-        static = await bsblan.static_values()
+
+        # Fetch device metadata in parallel for faster startup
+        device, info, static = await asyncio.gather(
+            bsblan.device(),
+            bsblan.info(),
+            bsblan.static_values(),
+        )
     except BSBLANConnectionError as err:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN,
@@ -110,10 +115,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
     fast_coordinator = BSBLanFastCoordinator(hass, entry, bsblan)
     slow_coordinator = BSBLanSlowCoordinator(hass, entry, bsblan)
 
-    # Perform first refresh of both coordinators
+    # Perform first refresh of fast coordinator (required for entities)
     await fast_coordinator.async_config_entry_first_refresh()
 
-    # Try to refresh slow coordinator, but don't fail if DHW is not available
+    # Refresh slow coordinator - don't fail if DHW is not available
     # This allows the integration to work even if the device doesn't support DHW
     await slow_coordinator.async_refresh()
 

homeassistant/components/bsblan/climate.py

@@ -111,11 +111,17 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
             return None
         return self.coordinator.data.state.target_temperature.value
 
+    @property
+    def _hvac_mode_value(self) -> int | str | None:
+        """Return the raw hvac_mode value from the coordinator."""
+        if (hvac_mode := self.coordinator.data.state.hvac_mode) is None:
+            return None
+        return hvac_mode.value
+
     @property
     def hvac_mode(self) -> HVACMode | None:
         """Return hvac operation ie. heat, cool mode."""
-        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
-        if hvac_mode_value is None:
+        if (hvac_mode_value := self._hvac_mode_value) is None:
             return None
         # BSB-Lan returns integer values: 0=off, 1=auto, 2=eco, 3=heat
         if isinstance(hvac_mode_value, int):
@@ -125,9 +131,8 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
         # BSB-Lan mode 2 is eco/reduced mode
-        if hvac_mode_value == 2:
+        if self._hvac_mode_value == 2:
             return PRESET_ECO
         return PRESET_NONE
 

homeassistant/components/bsblan/coordinator.py

@@ -2,7 +2,6 @@
 
 from dataclasses import dataclass
 from datetime import timedelta
-from random import randint
 
 from bsblan import (
     BSBLAN,
@@ -23,6 +22,17 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import DOMAIN, LOGGER, SCAN_INTERVAL_FAST, SCAN_INTERVAL_SLOW
 
+# Filter lists for optimized API calls - only fetch parameters we actually use
+# This significantly reduces response time (~0.2s per parameter saved)
+STATE_INCLUDE = ["current_temperature", "target_temperature", "hvac_mode"]
+SENSOR_INCLUDE = ["current_temperature", "outside_temperature"]
+DHW_STATE_INCLUDE = [
+    "operating_mode",
+    "nominal_setpoint",
+    "dhw_actual_value_top_temperature",
+]
+DHW_CONFIG_INCLUDE = ["reduced_setpoint", "nominal_setpoint_max"]
+
 
 @dataclass
 class BSBLanFastData:
@@ -80,26 +90,18 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
             config_entry,
             client,
             name=f"{DOMAIN}_fast_{config_entry.data[CONF_HOST]}",
-            update_interval=self._get_update_interval(),
+            update_interval=SCAN_INTERVAL_FAST,
         )
 
-    def _get_update_interval(self) -> timedelta:
-        """Get the update interval with a random offset.
-
-        Add a random number of seconds to avoid timeouts when
-        the BSB-Lan device is already/still busy retrieving data,
-        e.g. for MQTT or internal logging.
-        """
-        return SCAN_INTERVAL_FAST + timedelta(seconds=randint(1, 8))
-
     async def _async_update_data(self) -> BSBLanFastData:
         """Fetch fast-changing data from the BSB-Lan device."""
         try:
             # Client is already initialized in async_setup_entry
-            # Fetch fast-changing data (state, sensor, DHW state)
-            state = await self.client.state()
-            sensor = await self.client.sensor()
-            dhw = await self.client.hot_water_state()
+            # Use include filtering to only fetch parameters we actually use
+            # This reduces response time significantly (~0.2s per parameter)
+            state = await self.client.state(include=STATE_INCLUDE)
+            sensor = await self.client.sensor(include=SENSOR_INCLUDE)
+            dhw = await self.client.hot_water_state(include=DHW_STATE_INCLUDE)
 
         except BSBLANAuthError as err:
             raise ConfigEntryAuthFailed(
@@ -111,9 +113,6 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
                 f"Error while establishing connection with BSB-Lan device at {host}"
             ) from err
 
-        # Update the interval with random jitter for next update
-        self.update_interval = self._get_update_interval()
-
         return BSBLanFastData(
             state=state,
             sensor=sensor,
@@ -143,8 +142,8 @@ class BSBLanSlowCoordinator(BSBLanCoordinator[BSBLanSlowData]):
         """Fetch slow-changing data from the BSB-Lan device."""
         try:
             # Client is already initialized in async_setup_entry
-            # Fetch slow-changing configuration data
-            dhw_config = await self.client.hot_water_config()
+            # Use include filtering to only fetch parameters we actually use
+            dhw_config = await self.client.hot_water_config(include=DHW_CONFIG_INCLUDE)
             dhw_schedule = await self.client.hot_water_schedule()
 
         except AttributeError:

homeassistant/components/bsblan/entity.py

@@ -29,7 +29,11 @@ class BSBLanEntityBase[_T: BSBLanCoordinator](CoordinatorEntity[_T]):
             connections={(CONNECTION_NETWORK_MAC, format_mac(mac))},
             name=data.device.name,
             manufacturer="BSBLAN Inc.",
-            model=data.info.device_identification.value,
+            model=(
+                data.info.device_identification.value
+                if data.info.device_identification
+                else None
+            ),
             sw_version=data.device.version,
             configuration_url=f"http://{host}",
         )

homeassistant/components/bsblan/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==3.1.6"],
+  "requirements": ["python-bsblan==4.1.0"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.17.0"]
+  "requirements": ["bthome-ble==3.16.0"]
 }

homeassistant/components/calendar/icons.json

@@ -15,5 +15,13 @@
     "get_events": {
       "service": "mdi:calendar-month"
     }
+  },
+  "triggers": {
+    "event_ended": {
+      "trigger": "mdi:calendar-end"
+    },
+    "event_started": {
+      "trigger": "mdi:calendar-start"
+    }
   }
 }

homeassistant/components/calendar/strings.json

@@ -45,6 +45,14 @@
       "title": "Detected use of deprecated action calendar.list_events"
     }
   },
+  "selector": {
+    "trigger_offset_type": {
+      "options": {
+        "after": "After",
+        "before": "Before"
+      }
+    }
+  },
   "services": {
     "create_event": {
       "description": "Adds a new calendar event.",
@@ -103,5 +111,35 @@
       "name": "Get events"
     }
   },
-  "title": "Calendar"
+  "title": "Calendar",
+  "triggers": {
+    "event_ended": {
+      "description": "Triggers when a calendar event ends.",
+      "fields": {
+        "offset": {
+          "description": "Offset from the end of the event.",
+          "name": "Offset"
+        },
+        "offset_type": {
+          "description": "Whether to trigger before or after the end of the event, if an offset is defined.",
+          "name": "Offset type"
+        }
+      },
+      "name": "Calendar event ended"
+    },
+    "event_started": {
+      "description": "Triggers when a calendar event starts.",
+      "fields": {
+        "offset": {
+          "description": "Offset from the start of the event.",
+          "name": "Offset"
+        },
+        "offset_type": {
+          "description": "Whether to trigger before or after the start of the event, if an offset is defined.",
+          "name": "Offset type"
+        }
+      },
+      "name": "Calendar event started"
+    }
+  }
 }

homeassistant/components/calendar/trigger.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 import datetime
@@ -10,8 +11,15 @@ from typing import TYPE_CHECKING, Any, cast
 
 import voluptuous as vol
 
-from homeassistant.const import CONF_ENTITY_ID, CONF_EVENT, CONF_OFFSET, CONF_OPTIONS
-from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    CONF_ENTITY_ID,
+    CONF_EVENT,
+    CONF_OFFSET,
+    CONF_OPTIONS,
+    CONF_TARGET,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import move_top_level_schema_fields_to_options
@@ -20,12 +28,13 @@ from homeassistant.helpers.event import (
     async_track_point_in_time,
     async_track_time_interval,
 )
+from homeassistant.helpers.target import TargetEntityChangeTracker, TargetSelection
 from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
 
 from . import CalendarEntity, CalendarEvent
-from .const import DATA_COMPONENT
+from .const import DATA_COMPONENT, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,19 +42,35 @@ EVENT_START = "start"
 EVENT_END = "end"
 UPDATE_INTERVAL = datetime.timedelta(minutes=15)
 
+CONF_OFFSET_TYPE = "offset_type"
+OFFSET_TYPE_BEFORE = "before"
+OFFSET_TYPE_AFTER = "after"
 
-_OPTIONS_SCHEMA_DICT = {
+
+_SINGLE_ENTITY_EVENT_OPTIONS_SCHEMA = {
     vol.Required(CONF_ENTITY_ID): cv.entity_id,
     vol.Optional(CONF_EVENT, default=EVENT_START): vol.In({EVENT_START, EVENT_END}),
     vol.Optional(CONF_OFFSET, default=datetime.timedelta(0)): cv.time_period,
 }
 
-_CONFIG_SCHEMA = vol.Schema(
+_SINGLE_ENTITY_EVENT_TRIGGER_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_OPTIONS): _OPTIONS_SCHEMA_DICT,
+        vol.Required(CONF_OPTIONS): _SINGLE_ENTITY_EVENT_OPTIONS_SCHEMA,
     },
 )
 
+_EVENT_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_OPTIONS, default={}): {
+            vol.Required(CONF_OFFSET, default=datetime.timedelta(0)): cv.time_period,
+            vol.Required(CONF_OFFSET_TYPE, default=OFFSET_TYPE_BEFORE): vol.In(
+                {OFFSET_TYPE_BEFORE, OFFSET_TYPE_AFTER}
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
+    }
+)
+
 # mypy: disallow-any-generics
 
 
@@ -55,6 +80,7 @@ class QueuedCalendarEvent:
 
     trigger_time: datetime.datetime
     event: CalendarEvent
+    entity_id: str
 
 
 @dataclass
@@ -94,7 +120,7 @@ class Timespan:
         return f"[{self.start}, {self.end})"
 
 
-type EventFetcher = Callable[[Timespan], Awaitable[list[CalendarEvent]]]
+type EventFetcher = Callable[[Timespan], Awaitable[list[tuple[str, CalendarEvent]]]]
 type QueuedEventFetcher = Callable[[Timespan], Awaitable[list[QueuedCalendarEvent]]]
 
 
@@ -110,15 +136,24 @@ def get_entity(hass: HomeAssistant, entity_id: str) -> CalendarEntity:
     return entity
 
 
-def event_fetcher(hass: HomeAssistant, entity_id: str) -> EventFetcher:
+def event_fetcher(hass: HomeAssistant, entity_ids: set[str]) -> EventFetcher:
     """Build an async_get_events wrapper to fetch events during a time span."""
 
-    async def async_get_events(timespan: Timespan) -> list[CalendarEvent]:
+    async def async_get_events(timespan: Timespan) -> list[tuple[str, CalendarEvent]]:
         """Return events active in the specified time span."""
-        entity = get_entity(hass, entity_id)
         # Expand by one second to make the end time exclusive
         end_time = timespan.end + datetime.timedelta(seconds=1)
-        return await entity.async_get_events(hass, timespan.start, end_time)
+
+        events: list[tuple[str, CalendarEvent]] = []
+        for entity_id in entity_ids:
+            entity = get_entity(hass, entity_id)
+            events.extend(
+                (entity_id, event)
+                for event in await entity.async_get_events(
+                    hass, timespan.start, end_time
+                )
+            )
+        return events
 
     return async_get_events
 
@@ -142,12 +177,11 @@ def queued_event_fetcher(
         # Example: For an EVENT_END trigger the event may start during this
         # time span, but need to be triggered later when the end happens.
         results = []
-        for trigger_time, event in zip(
-            map(get_trigger_time, active_events), active_events, strict=False
-        ):
+        for entity_id, event in active_events:
+            trigger_time = get_trigger_time(event)
             if trigger_time not in offset_timespan:
                 continue
-            results.append(QueuedCalendarEvent(trigger_time + offset, event))
+            results.append(QueuedCalendarEvent(trigger_time + offset, event, entity_id))
 
         _LOGGER.debug(
             "Scan events @ %s%s found %s eligible of %s active",
@@ -240,6 +274,7 @@ class CalendarEventListener:
             _LOGGER.debug("Dispatching event: %s", queued_event.event)
             payload = {
                 **self._trigger_payload,
+                ATTR_ENTITY_ID: queued_event.entity_id,
                 "calendar_event": queued_event.event.as_dict(),
             }
             self._action_runner(payload, "calendar event state change")
@@ -260,8 +295,77 @@ class CalendarEventListener:
         self._listen_next_calendar_event()
 
 
-class EventTrigger(Trigger):
-    """Calendar event trigger."""
+class TargetCalendarEventListener(TargetEntityChangeTracker):
+    """Helper class to listen to calendar events for target entity changes."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        target_selection: TargetSelection,
+        event_type: str,
+        offset: datetime.timedelta,
+        run_action: TriggerActionRunner,
+    ) -> None:
+        """Initialize the state change tracker."""
+
+        def entity_filter(entities: set[str]) -> set[str]:
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        super().__init__(hass, target_selection, entity_filter)
+        self._event_type = event_type
+        self._offset = offset
+        self._run_action = run_action
+        self._trigger_data = {
+            "event": event_type,
+            "offset": offset,
+        }
+
+        self._pending_listener_task: asyncio.Task[None] | None = None
+        self._calendar_event_listener: CalendarEventListener | None = None
+
+    @callback
+    def _handle_entities_update(self, tracked_entities: set[str]) -> None:
+        """Restart the listeners when the list of entities of the tracked targets is updated."""
+        if self._pending_listener_task:
+            self._pending_listener_task.cancel()
+        self._pending_listener_task = self._hass.async_create_task(
+            self._start_listening(tracked_entities)
+        )
+
+    async def _start_listening(self, tracked_entities: set[str]) -> None:
+        """Start listening for calendar events."""
+        _LOGGER.debug("Tracking events for calendars: %s", tracked_entities)
+        if self._calendar_event_listener:
+            self._calendar_event_listener.async_detach()
+        self._calendar_event_listener = CalendarEventListener(
+            self._hass,
+            self._run_action,
+            self._trigger_data,
+            queued_event_fetcher(
+                event_fetcher(self._hass, tracked_entities),
+                self._event_type,
+                self._offset,
+            ),
+        )
+        await self._calendar_event_listener.async_attach()
+
+    def _unsubscribe(self) -> None:
+        """Unsubscribe from all events."""
+        super()._unsubscribe()
+        if self._pending_listener_task:
+            self._pending_listener_task.cancel()
+            self._pending_listener_task = None
+        if self._calendar_event_listener:
+            self._calendar_event_listener.async_detach()
+            self._calendar_event_listener = None
+
+
+class SingleEntityEventTrigger(Trigger):
+    """Legacy single calendar entity event trigger."""
 
     _options: dict[str, Any]
 
@@ -271,7 +375,7 @@ class EventTrigger(Trigger):
     ) -> ConfigType:
         """Validate complete config."""
         complete_config = move_top_level_schema_fields_to_options(
-            complete_config, _OPTIONS_SCHEMA_DICT
+            complete_config, _SINGLE_ENTITY_EVENT_OPTIONS_SCHEMA
         )
         return await super().async_validate_complete_config(hass, complete_config)
 
@@ -280,7 +384,7 @@ class EventTrigger(Trigger):
         cls, hass: HomeAssistant, config: ConfigType
     ) -> ConfigType:
         """Validate config."""
-        return cast(ConfigType, _CONFIG_SCHEMA(config))
+        return cast(ConfigType, _SINGLE_ENTITY_EVENT_TRIGGER_SCHEMA(config))
 
     def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
         """Initialize trigger."""
@@ -311,15 +415,72 @@ class EventTrigger(Trigger):
             run_action,
             trigger_data,
             queued_event_fetcher(
-                event_fetcher(self._hass, entity_id), event_type, offset
+                event_fetcher(self._hass, {entity_id}), event_type, offset
             ),
         )
         await listener.async_attach()
         return listener.async_detach
 
 
+class EventTrigger(Trigger):
+    """Calendar event trigger."""
+
+    _options: dict[str, Any]
+    _event_type: str
+
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, _EVENT_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize trigger."""
+        super().__init__(hass, config)
+
+        if TYPE_CHECKING:
+            assert config.target is not None
+            assert config.options is not None
+        self._target = config.target
+        self._options = config.options
+
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach a trigger."""
+
+        offset = self._options[CONF_OFFSET]
+        offset_type = self._options[CONF_OFFSET_TYPE]
+
+        if offset_type == OFFSET_TYPE_BEFORE:
+            offset = -offset
+
+        target_selection = TargetSelection(self._target)
+        if not target_selection.has_any_target:
+            raise HomeAssistantError(f"No target defined in {self._target}")
+        listener = TargetCalendarEventListener(
+            self._hass, target_selection, self._event_type, offset, run_action
+        )
+        return listener.async_setup()
+
+
+class EventStartedTrigger(EventTrigger):
+    """Calendar event started trigger."""
+
+    _event_type = EVENT_START
+
+
+class EventEndedTrigger(EventTrigger):
+    """Calendar event ended trigger."""
+
+    _event_type = EVENT_END
+
+
 TRIGGERS: dict[str, type[Trigger]] = {
-    "_": EventTrigger,
+    "_": SingleEntityEventTrigger,
+    "event_started": EventStartedTrigger,
+    "event_ended": EventEndedTrigger,
 }
 
 

homeassistant/components/calendar/triggers.yaml

@@ -0,0 +1,27 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: calendar
+  fields:
+    offset:
+      required: true
+      default:
+        days: 0
+        hours: 0
+        minutes: 0
+        seconds: 0
+      selector:
+        duration:
+          enable_day: true
+    offset_type:
+      required: true
+      default: before
+      selector:
+        select:
+          translation_key: trigger_offset_type
+          options:
+            - before
+            - after
+
+event_started: *trigger_common
+event_ended: *trigger_common

homeassistant/components/cisco_webex_teams/notify.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 import voluptuous as vol
 from webexpythonsdk import ApiError, WebexAPI, exceptions
@@ -51,7 +52,7 @@ class CiscoWebexNotificationService(BaseNotificationService):
         self.room = room
         self.client = client
 
-    def send_message(self, message="", **kwargs):
+    def send_message(self, message: str = "", **kwargs: Any) -> None:
         """Send a message to a user."""
 
         title = ""

homeassistant/components/clicksend_tts/notify.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from http import HTTPStatus
 import json
 import logging
+from typing import Any
 
 import requests
 import voluptuous as vol
@@ -81,7 +82,7 @@ class ClicksendNotificationService(BaseNotificationService):
         self.language = config[CONF_LANGUAGE]
         self.voice = config[CONF_VOICE]
 
-    def send_message(self, message="", **kwargs):
+    def send_message(self, message: str = "", **kwargs: Any) -> None:
         """Send a voice call to a user."""
         data = {
             "messages": [

homeassistant/components/climate/trigger.py

@@ -33,7 +33,7 @@ HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend
     {
         vol.Required(CONF_OPTIONS): {
             vol.Required(CONF_HVAC_MODE): vol.All(
-                cv.ensure_list, vol.Length(min=1), [HVACMode]
+                cv.ensure_list, vol.Length(min=1), [vol.Coerce(HVACMode)]
             ),
         },
     }

homeassistant/components/climate/triggers.yaml

@@ -19,6 +19,10 @@
   selector:
     choose:
       choices:
+        number:
+          selector:
+            number:
+              mode: box
         entity:
           selector:
             entity:
@@ -27,14 +31,11 @@
                   - input_number
                   - number
                   - sensor
-        number:
-          selector:
-            number:
-              mode: box
       translation_key: number_or_entity
 
 .trigger_threshold_type: &trigger_threshold_type
   required: true
+  default: above
   selector:
     select:
       options:

homeassistant/components/cloud/__init__.py

@@ -50,7 +50,6 @@ from . import (
 from .client import CloudClient
 from .const import (
     CONF_ACCOUNT_LINK_SERVER,
-    CONF_ACCOUNTS_SERVER,
     CONF_ACME_SERVER,
     CONF_ALEXA,
     CONF_ALIASES,
@@ -138,7 +137,6 @@ _BASE_CONFIG_SCHEMA = vol.Schema(
         vol.Optional(CONF_ALEXA): ALEXA_SCHEMA,
         vol.Optional(CONF_GOOGLE_ACTIONS): GACTIONS_SCHEMA,
         vol.Optional(CONF_ACCOUNT_LINK_SERVER): str,
-        vol.Optional(CONF_ACCOUNTS_SERVER): str,
         vol.Optional(CONF_ACME_SERVER): str,
         vol.Optional(CONF_API_SERVER): str,
         vol.Optional(CONF_RELAYER_SERVER): str,

homeassistant/components/cloud/const.py

@@ -76,7 +76,6 @@ CONF_GOOGLE_ACTIONS = "google_actions"
 CONF_USER_POOL_ID = "user_pool_id"
 
 CONF_ACCOUNT_LINK_SERVER = "account_link_server"
-CONF_ACCOUNTS_SERVER = "accounts_server"
 CONF_ACME_SERVER = "acme_server"
 CONF_API_SERVER = "api_server"
 CONF_DISCOVERY_SERVICE_ACTIONS = "discovery_service_actions"

homeassistant/components/cloud/manifest.json

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

homeassistant/components/concord232/binary_sensor.py

@@ -119,7 +119,7 @@ class Concord232ZoneSensor(BinarySensorEntity):
         self._zone_type = zone_type
 
     @property
-    def device_class(self):
+    def device_class(self) -> BinarySensorDeviceClass:
         """Return the class of this sensor, from DEVICE_CLASSES."""
         return self._zone_type
 

homeassistant/components/config/entity_registry.py

@@ -11,13 +11,11 @@ from homeassistant import config_entries
 from homeassistant.components import websocket_api
 from homeassistant.components.websocket_api import ERR_NOT_FOUND, require_admin
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     entity_registry as er,
 )
-from homeassistant.helpers.entity_component import async_get_entity_suggested_object_id
 from homeassistant.helpers.json import json_dumps
 
 _LOGGER = logging.getLogger(__name__)
@@ -351,26 +349,12 @@ def websocket_get_automatic_entity_ids(
         if not (entry := registry.entities.get(entity_id)):
             automatic_entity_ids[entity_id] = None
             continue
-        try:
-            suggested = async_get_entity_suggested_object_id(hass, entity_id)
-        except HomeAssistantError as err:
-            # This is raised if the entity has no object.
-            _LOGGER.debug(
-                "Unable to get suggested object ID for %s, entity ID: %s (%s)",
-                entry.entity_id,
-                entity_id,
-                err,
-            )
-            automatic_entity_ids[entity_id] = None
-            continue
-        suggested_entity_id = registry.async_generate_entity_id(
-            entry.domain,
-            suggested or f"{entry.platform}_{entry.unique_id}",
-            current_entity_id=entity_id,
+        new_entity_id = registry.async_regenerate_entity_id(
+            entry,
             reserved_entity_ids=reserved_entity_ids,
         )
-        automatic_entity_ids[entity_id] = suggested_entity_id
-        reserved_entity_ids.add(suggested_entity_id)
+        automatic_entity_ids[entity_id] = new_entity_id
+        reserved_entity_ids.add(new_entity_id)
 
     connection.send_message(
         websocket_api.result_message(msg["id"], automatic_entity_ids)

homeassistant/components/datadog/manifest.json

@@ -7,6 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_push",
   "loggers": ["datadog"],
-  "quality_scale": "legacy",
   "requirements": ["datadog==0.52.0"]
 }

homeassistant/components/deconz/device_trigger.py

@@ -169,6 +169,7 @@ FRIENDS_OF_HUE_SWITCH = {
 }
 
 RODRET_REMOTE_MODEL = "RODRET Dimmer"
+RODRET_REMOTE_MODEL_2 = "RODRET wireless dimmer"
 RODRET_REMOTE = {
     (CONF_SHORT_RELEASE, CONF_TURN_ON): {CONF_EVENT: 1002},
     (CONF_LONG_PRESS, CONF_TURN_ON): {CONF_EVENT: 1001},
@@ -624,6 +625,7 @@ REMOTES = {
     HUE_WALL_REMOTE_MODEL: HUE_WALL_REMOTE,
     FRIENDS_OF_HUE_SWITCH_MODEL: FRIENDS_OF_HUE_SWITCH,
     RODRET_REMOTE_MODEL: RODRET_REMOTE,
+    RODRET_REMOTE_MODEL_2: RODRET_REMOTE,
     SOMRIG_REMOTE_MODEL: SOMRIG_REMOTE,
     STYRBAR_REMOTE_MODEL: STYRBAR_REMOTE,
     SYMFONISK_SOUND_CONTROLLER_MODEL: SYMFONISK_SOUND_CONTROLLER,

homeassistant/components/demo/humidifier.py

@@ -28,10 +28,11 @@ async def async_setup_entry(
             DemoHumidifier(
                 name="Humidifier",
                 mode=None,
-                target_humidity=68,
+                target_humidity=65,
                 current_humidity=45,
                 action=HumidifierAction.HUMIDIFYING,
                 device_class=HumidifierDeviceClass.HUMIDIFIER,
+                target_humidity_step=5,
             ),
             DemoHumidifier(
                 name="Dehumidifier",
@@ -66,6 +67,7 @@ class DemoHumidifier(HumidifierEntity):
         is_on: bool = True,
         action: HumidifierAction | None = None,
         device_class: HumidifierDeviceClass | None = None,
+        target_humidity_step: float | None = None,
     ) -> None:
         """Initialize the humidifier device."""
         self._attr_name = name
@@ -79,6 +81,7 @@ class DemoHumidifier(HumidifierEntity):
         self._attr_mode = mode
         self._attr_available_modes = available_modes
         self._attr_device_class = device_class
+        self._attr_target_humidity_step = target_humidity_step
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""

homeassistant/components/digital_ocean/binary_sensor.py

@@ -84,7 +84,7 @@ class DigitalOceanBinarySensor(BinarySensorEntity):
         return self.data.status == "active"
 
     @property
-    def device_class(self):
+    def device_class(self) -> BinarySensorDeviceClass:
         """Return the class of this sensor."""
         return BinarySensorDeviceClass.MOVING
 

homeassistant/components/dnsip/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/dnsip",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["aiodns==3.6.1"]
+  "requirements": ["aiodns==4.0.0"]
 }

homeassistant/components/dovado/notify.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 from homeassistant.components.notify import ATTR_TARGET, BaseNotificationService
 from homeassistant.core import HomeAssistant
@@ -29,7 +30,7 @@ class DovadoSMSNotificationService(BaseNotificationService):
         """Initialize the service."""
         self._client = client
 
-    def send_message(self, message, **kwargs):
+    def send_message(self, message: str, **kwargs: Any) -> None:
         """Send SMS to the specified target phone number."""
         if not (target := kwargs.get(ATTR_TARGET)):
             _LOGGER.error("One target is required")

homeassistant/components/easyenergy/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/easyenergy",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["easyenergy==2.1.2"],
+  "requirements": ["easyenergy==2.2.0"],
   "single_config_entry": true
 }

homeassistant/components/ebusd/sensor.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import datetime
 import logging
 
-from homeassistant.components.sensor import SensorEntity
+from homeassistant.components.sensor import SensorDeviceClass, SensorEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
@@ -96,7 +96,7 @@ class EbusdSensor(SensorEntity):
         return None
 
     @property
-    def device_class(self):
+    def device_class(self) -> SensorDeviceClass | None:
         """Return the class of this device, from component DEVICE_CLASSES."""
         return self._device_class
 

homeassistant/components/ecovacs/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.11", "deebot-client==17.0.0"]
+  "requirements": ["py-sucks==0.9.11", "deebot-client==17.0.1"]
 }

homeassistant/components/egardia/binary_sensor.py

@@ -75,6 +75,6 @@ class EgardiaBinarySensor(BinarySensorEntity):
         return self._state == STATE_ON
 
     @property
-    def device_class(self):
+    def device_class(self) -> BinarySensorDeviceClass | None:
         """Return the device class."""
         return self._device_class

homeassistant/components/eheimdigital/entity.py

@@ -37,7 +37,7 @@ class EheimDigitalEntity[_DeviceT: EheimDigitalDevice](
             name=device.name,
             connections={(CONNECTION_NETWORK_MAC, device.mac_address)},
             manufacturer="EHEIM",
-            model=device.device_type.model_name,
+            model=device.model_name,
             identifiers={(DOMAIN, device.mac_address)},
             suggested_area=device.aquarium_name,
             sw_version=device.sw_version,
@@ -59,9 +59,9 @@ class EheimDigitalEntity[_DeviceT: EheimDigitalDevice](
 def exception_handler[_EntityT: EheimDigitalEntity[EheimDigitalDevice], **_P](
     func: Callable[Concatenate[_EntityT, _P], Coroutine[Any, Any, Any]],
 ) -> Callable[Concatenate[_EntityT, _P], Coroutine[Any, Any, None]]:
-    """Decorate AirGradient calls to handle exceptions.
+    """Decorate eheimdigital calls to handle exceptions.
 
-    A decorator that wraps the passed in function, catches AirGradient errors.
+    A decorator that wraps the passed in function, catches eheimdigital errors.
     """
 
     async def handler(self: _EntityT, *args: _P.args, **kwargs: _P.kwargs) -> None:

homeassistant/components/eheimdigital/number.py

@@ -6,6 +6,7 @@ from typing import Any, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
+from eheimdigital.filter import EheimDigitalFilter
 from eheimdigital.heater import EheimDigitalHeater
 from eheimdigital.types import HeaterUnit
 
@@ -21,6 +22,7 @@ from homeassistant.const import (
     PRECISION_WHOLE,
     EntityCategory,
     UnitOfTemperature,
+    UnitOfTime,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -42,6 +44,34 @@ class EheimDigitalNumberDescription[_DeviceT: EheimDigitalDevice](
     uom_fn: Callable[[_DeviceT], str] | None = None
 
 
+FILTER_DESCRIPTIONS: tuple[EheimDigitalNumberDescription[EheimDigitalFilter], ...] = (
+    EheimDigitalNumberDescription[EheimDigitalFilter](
+        key="high_pulse_time",
+        translation_key="high_pulse_time",
+        entity_category=EntityCategory.CONFIG,
+        native_step=PRECISION_WHOLE,
+        native_unit_of_measurement=UnitOfTime.SECONDS,
+        device_class=NumberDeviceClass.DURATION,
+        native_min_value=5,
+        native_max_value=200000,
+        value_fn=lambda device: device.high_pulse_time,
+        set_value_fn=lambda device, value: device.set_high_pulse_time(int(value)),
+    ),
+    EheimDigitalNumberDescription[EheimDigitalFilter](
+        key="low_pulse_time",
+        translation_key="low_pulse_time",
+        entity_category=EntityCategory.CONFIG,
+        native_step=PRECISION_WHOLE,
+        native_unit_of_measurement=UnitOfTime.SECONDS,
+        device_class=NumberDeviceClass.DURATION,
+        native_min_value=5,
+        native_max_value=200000,
+        value_fn=lambda device: device.low_pulse_time,
+        set_value_fn=lambda device, value: device.set_low_pulse_time(int(value)),
+    ),
+)
+
+
 CLASSICVARIO_DESCRIPTIONS: tuple[
     EheimDigitalNumberDescription[EheimDigitalClassicVario], ...
 ] = (
@@ -145,6 +175,13 @@ async def async_setup_entry(
                     )
                     for description in CLASSICVARIO_DESCRIPTIONS
                 )
+            if isinstance(device, EheimDigitalFilter):
+                entities.extend(
+                    EheimDigitalNumber[EheimDigitalFilter](
+                        coordinator, device, description
+                    )
+                    for description in FILTER_DESCRIPTIONS
+                )
             if isinstance(device, EheimDigitalHeater):
                 entities.extend(
                     EheimDigitalNumber[EheimDigitalHeater](

homeassistant/components/eheimdigital/select.py

@@ -2,13 +2,19 @@
 
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Any, override
+from typing import Any, Literal, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
-from eheimdigital.types import FilterMode
+from eheimdigital.filter import EheimDigitalFilter
+from eheimdigital.types import (
+    FilterMode,
+    FilterModeProf,
+    UnitOfMeasurement as EheimDigitalUnitOfMeasurement,
+)
 
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
+from homeassistant.const import EntityCategory, UnitOfFrequency, UnitOfVolumeFlowRate
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -24,8 +30,109 @@ class EheimDigitalSelectDescription[_DeviceT: EheimDigitalDevice](
 ):
     """Class describing EHEIM Digital select entities."""
 
+    options_fn: Callable[[_DeviceT], list[str]] | None = None
+    use_api_unit: Literal[True] | None = None
     value_fn: Callable[[_DeviceT], str | None]
-    set_value_fn: Callable[[_DeviceT, str], Awaitable[None]]
+    set_value_fn: Callable[[_DeviceT, str], Awaitable[None] | None]
+
+
+FILTER_DESCRIPTIONS: tuple[EheimDigitalSelectDescription[EheimDigitalFilter], ...] = (
+    EheimDigitalSelectDescription[EheimDigitalFilter](
+        key="filter_mode",
+        translation_key="filter_mode",
+        entity_category=EntityCategory.CONFIG,
+        options=[item.lower() for item in FilterModeProf._member_names_],
+        value_fn=lambda device: device.filter_mode.name.lower(),
+        set_value_fn=lambda device, value: device.set_filter_mode(
+            FilterModeProf[value.upper()]
+        ),
+    ),
+    EheimDigitalSelectDescription[EheimDigitalFilter](
+        key="manual_speed",
+        translation_key="manual_speed",
+        entity_category=EntityCategory.CONFIG,
+        unit_of_measurement=UnitOfFrequency.HERTZ,
+        options_fn=lambda device: [str(i) for i in device.filter_manual_values],
+        value_fn=lambda device: str(device.manual_speed),
+        set_value_fn=lambda device, value: device.set_manual_speed(float(value)),
+    ),
+    EheimDigitalSelectDescription[EheimDigitalFilter](
+        key="const_flow_speed",
+        translation_key="const_flow_speed",
+        entity_category=EntityCategory.CONFIG,
+        use_api_unit=True,
+        unit_of_measurement=UnitOfVolumeFlowRate.LITERS_PER_HOUR,
+        options_fn=lambda device: [str(i) for i in device.filter_const_flow_values],
+        value_fn=lambda device: str(device.filter_const_flow_values[device.const_flow]),
+        set_value_fn=(
+            lambda device, value: device.set_const_flow(
+                device.filter_const_flow_values.index(int(value))
+            )
+        ),
+    ),
+    EheimDigitalSelectDescription[EheimDigitalFilter](
+        key="day_speed",
+        translation_key="day_speed",
+        entity_category=EntityCategory.CONFIG,
+        use_api_unit=True,
+        unit_of_measurement=UnitOfVolumeFlowRate.LITERS_PER_HOUR,
+        options_fn=lambda device: [str(i) for i in device.filter_const_flow_values],
+        value_fn=lambda device: str(device.filter_const_flow_values[device.day_speed]),
+        set_value_fn=(
+            lambda device, value: device.set_day_speed(
+                device.filter_const_flow_values.index(int(value))
+            )
+        ),
+    ),
+    EheimDigitalSelectDescription[EheimDigitalFilter](
+        key="night_speed",
+        translation_key="night_speed",
+        entity_category=EntityCategory.CONFIG,
+        use_api_unit=True,
+        unit_of_measurement=UnitOfVolumeFlowRate.LITERS_PER_HOUR,
+        options_fn=lambda device: [str(i) for i in device.filter_const_flow_values],
+        value_fn=lambda device: str(
+            device.filter_const_flow_values[device.night_speed]
+        ),
+        set_value_fn=(
+            lambda device, value: device.set_night_speed(
+                device.filter_const_flow_values.index(int(value))
+            )
+        ),
+    ),
+    EheimDigitalSelectDescription[EheimDigitalFilter](
+        key="high_pulse_speed",
+        translation_key="high_pulse_speed",
+        entity_category=EntityCategory.CONFIG,
+        use_api_unit=True,
+        unit_of_measurement=UnitOfVolumeFlowRate.LITERS_PER_HOUR,
+        options_fn=lambda device: [str(i) for i in device.filter_const_flow_values],
+        value_fn=lambda device: str(
+            device.filter_const_flow_values[device.high_pulse_speed]
+        ),
+        set_value_fn=(
+            lambda device, value: device.set_high_pulse_speed(
+                device.filter_const_flow_values.index(int(value))
+            )
+        ),
+    ),
+    EheimDigitalSelectDescription[EheimDigitalFilter](
+        key="low_pulse_speed",
+        translation_key="low_pulse_speed",
+        entity_category=EntityCategory.CONFIG,
+        use_api_unit=True,
+        unit_of_measurement=UnitOfVolumeFlowRate.LITERS_PER_HOUR,
+        options_fn=lambda device: [str(i) for i in device.filter_const_flow_values],
+        value_fn=lambda device: str(
+            device.filter_const_flow_values[device.low_pulse_speed]
+        ),
+        set_value_fn=(
+            lambda device, value: device.set_low_pulse_speed(
+                device.filter_const_flow_values.index(int(value))
+            )
+        ),
+    ),
+)
 
 
 CLASSICVARIO_DESCRIPTIONS: tuple[
@@ -34,11 +141,7 @@ CLASSICVARIO_DESCRIPTIONS: tuple[
     EheimDigitalSelectDescription[EheimDigitalClassicVario](
         key="filter_mode",
         translation_key="filter_mode",
-        value_fn=(
-            lambda device: device.filter_mode.name.lower()
-            if device.filter_mode is not None
-            else None
-        ),
+        value_fn=lambda device: device.filter_mode.name.lower(),
         set_value_fn=(
             lambda device, value: device.set_filter_mode(FilterMode[value.upper()])
         ),
@@ -68,6 +171,11 @@ async def async_setup_entry(
                     )
                     for description in CLASSICVARIO_DESCRIPTIONS
                 )
+            if isinstance(device, EheimDigitalFilter):
+                entities.extend(
+                    EheimDigitalFilterSelect(coordinator, device, description)
+                    for description in FILTER_DESCRIPTIONS
+                )
 
         async_add_entities(entities)
 
@@ -82,6 +190,8 @@ class EheimDigitalSelect[_DeviceT: EheimDigitalDevice](
 
     entity_description: EheimDigitalSelectDescription[_DeviceT]
 
+    _attr_options: list[str]
+
     def __init__(
         self,
         coordinator: EheimDigitalUpdateCoordinator,
@@ -91,13 +201,49 @@ class EheimDigitalSelect[_DeviceT: EheimDigitalDevice](
         """Initialize an EHEIM Digital select entity."""
         super().__init__(coordinator, device)
         self.entity_description = description
+        if description.options_fn is not None:
+            self._attr_options = description.options_fn(device)
+        elif description.options is not None:
+            self._attr_options = description.options
         self._attr_unique_id = f"{self._device_address}_{description.key}"
 
     @override
     @exception_handler
     async def async_select_option(self, option: str) -> None:
-        return await self.entity_description.set_value_fn(self._device, option)
+        if await_return := self.entity_description.set_value_fn(self._device, option):
+            return await await_return
+        return None
 
     @override
     def _async_update_attrs(self) -> None:
         self._attr_current_option = self.entity_description.value_fn(self._device)
+
+
+class EheimDigitalFilterSelect(EheimDigitalSelect[EheimDigitalFilter]):
+    """Represent an EHEIM Digital Filter select entity."""
+
+    entity_description: EheimDigitalSelectDescription[EheimDigitalFilter]
+    _attr_native_unit_of_measurement: str | None
+
+    @override
+    def _async_update_attrs(self) -> None:
+        if (
+            self.entity_description.options is None
+            and self.entity_description.options_fn is not None
+        ):
+            self._attr_options = self.entity_description.options_fn(self._device)
+        if self.entity_description.use_api_unit:
+            if (
+                self.entity_description.unit_of_measurement
+                == UnitOfVolumeFlowRate.LITERS_PER_HOUR
+                and self._device.usrdta["unit"]
+                == int(EheimDigitalUnitOfMeasurement.US_CUSTOMARY)
+            ):
+                self._attr_native_unit_of_measurement = (
+                    UnitOfVolumeFlowRate.GALLONS_PER_HOUR
+                )
+        else:
+            self._attr_native_unit_of_measurement = (
+                self.entity_description.unit_of_measurement
+            )
+        super()._async_update_attrs()

homeassistant/components/eheimdigital/sensor.py

@@ -6,6 +6,7 @@ from typing import Any, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
+from eheimdigital.filter import EheimDigitalFilter
 from eheimdigital.types import FilterErrorCode
 
 from homeassistant.components.sensor import (
@@ -13,7 +14,7 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfTime
+from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfFrequency, UnitOfTime
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -33,6 +34,27 @@ class EheimDigitalSensorDescription[_DeviceT: EheimDigitalDevice](
     value_fn: Callable[[_DeviceT], float | str | None]
 
 
+FILTER_DESCRIPTIONS: tuple[EheimDigitalSensorDescription[EheimDigitalFilter], ...] = (
+    EheimDigitalSensorDescription[EheimDigitalFilter](
+        key="current_speed",
+        translation_key="current_speed",
+        value_fn=lambda device: device.current_speed,
+        device_class=SensorDeviceClass.FREQUENCY,
+        suggested_display_precision=1,
+        native_unit_of_measurement=UnitOfFrequency.HERTZ,
+    ),
+    EheimDigitalSensorDescription[EheimDigitalFilter](
+        key="service_hours",
+        translation_key="service_hours",
+        value_fn=lambda device: device.service_hours,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        suggested_unit_of_measurement=UnitOfTime.DAYS,
+        entity_category=EntityCategory.DIAGNOSTIC,
+    ),
+)
+
+
 CLASSICVARIO_DESCRIPTIONS: tuple[
     EheimDigitalSensorDescription[EheimDigitalClassicVario], ...
 ] = (
@@ -54,11 +76,7 @@ CLASSICVARIO_DESCRIPTIONS: tuple[
     EheimDigitalSensorDescription[EheimDigitalClassicVario](
         key="error_code",
         translation_key="error_code",
-        value_fn=(
-            lambda device: device.error_code.name.lower()
-            if device.error_code is not None
-            else None
-        ),
+        value_fn=lambda device: device.error_code.name.lower(),
         device_class=SensorDeviceClass.ENUM,
         options=[name.lower() for name in FilterErrorCode._member_names_],
         entity_category=EntityCategory.DIAGNOSTIC,
@@ -80,6 +98,13 @@ async def async_setup_entry(
         """Set up the light entities for one or multiple devices."""
         entities: list[EheimDigitalSensor[Any]] = []
         for device in device_address.values():
+            if isinstance(device, EheimDigitalFilter):
+                entities += [
+                    EheimDigitalSensor[EheimDigitalFilter](
+                        coordinator, device, description
+                    )
+                    for description in FILTER_DESCRIPTIONS
+                ]
             if isinstance(device, EheimDigitalClassicVario):
                 entities += [
                     EheimDigitalSensor[EheimDigitalClassicVario](

homeassistant/components/eheimdigital/strings.json

@@ -61,6 +61,12 @@
       "day_speed": {
         "name": "Day speed"
       },
+      "high_pulse_time": {
+        "name": "High pulse duration"
+      },
+      "low_pulse_time": {
+        "name": "Low pulse duration"
+      },
       "manual_speed": {
         "name": "Manual speed"
       },
@@ -78,13 +84,32 @@
       }
     },
     "select": {
+      "const_flow_speed": {
+        "name": "Constant flow speed"
+      },
+      "day_speed": {
+        "name": "Day speed"
+      },
       "filter_mode": {
         "name": "Filter mode",
         "state": {
           "bio": "Bio",
+          "constant_flow": "Constant flow",
           "manual": "Manual",
           "pulse": "Pulse"
         }
+      },
+      "high_pulse_speed": {
+        "name": "High pulse speed"
+      },
+      "low_pulse_speed": {
+        "name": "Low pulse speed"
+      },
+      "manual_speed": {
+        "name": "Manual speed"
+      },
+      "night_speed": {
+        "name": "Night speed"
       }
     },
     "sensor": {
@@ -99,8 +124,17 @@
           "rotor_stuck": "Rotor stuck"
         }
       },
+      "operating_time": {
+        "name": "Operating time"
+      },
       "service_hours": {
         "name": "Remaining hours until service"
+      },
+      "turn_feeding_time": {
+        "name": "Remaining off time after feeding"
+      },
+      "turn_off_time": {
+        "name": "Remaining off time"
       }
     },
     "time": {

homeassistant/components/eheimdigital/switch.py

@@ -4,6 +4,7 @@ from typing import Any, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
+from eheimdigital.filter import EheimDigitalFilter
 
 from homeassistant.components.switch import SwitchEntity
 from homeassistant.core import HomeAssistant
@@ -30,8 +31,8 @@ async def async_setup_entry(
         """Set up the switch entities for one or multiple devices."""
         entities: list[SwitchEntity] = []
         for device in device_address.values():
-            if isinstance(device, EheimDigitalClassicVario):
-                entities.append(EheimDigitalClassicVarioSwitch(coordinator, device))  # noqa: PERF401
+            if isinstance(device, (EheimDigitalClassicVario, EheimDigitalFilter)):
+                entities.append(EheimDigitalFilterSwitch(coordinator, device))  # noqa: PERF401
 
         async_add_entities(entities)
 
@@ -39,10 +40,10 @@ async def async_setup_entry(
     async_setup_device_entities(coordinator.hub.devices)
 
 
-class EheimDigitalClassicVarioSwitch(
-    EheimDigitalEntity[EheimDigitalClassicVario], SwitchEntity
+class EheimDigitalFilterSwitch(
+    EheimDigitalEntity[EheimDigitalClassicVario | EheimDigitalFilter], SwitchEntity
 ):
-    """Represent an EHEIM Digital classicVARIO switch entity."""
+    """Represent an EHEIM Digital classicVARIO or filter switch entity."""
 
     _attr_translation_key = "filter_active"
     _attr_name = None
@@ -50,9 +51,9 @@ class EheimDigitalClassicVarioSwitch(
     def __init__(
         self,
         coordinator: EheimDigitalUpdateCoordinator,
-        device: EheimDigitalClassicVario,
+        device: EheimDigitalClassicVario | EheimDigitalFilter,
     ) -> None:
-        """Initialize an EHEIM Digital classicVARIO switch entity."""
+        """Initialize an EHEIM Digital classicVARIO or filter switch entity."""
         super().__init__(coordinator, device)
         self._attr_unique_id = device.mac_address
         self._async_update_attrs()

homeassistant/components/eheimdigital/time.py

@@ -7,6 +7,7 @@ from typing import Any, final, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
+from eheimdigital.filter import EheimDigitalFilter
 from eheimdigital.heater import EheimDigitalHeater
 
 from homeassistant.components.time import TimeEntity, TimeEntityDescription
@@ -28,6 +29,23 @@ class EheimDigitalTimeDescription[_DeviceT: EheimDigitalDevice](TimeEntityDescri
     set_value_fn: Callable[[_DeviceT, time], Awaitable[None]]
 
 
+FILTER_DESCRIPTIONS: tuple[EheimDigitalTimeDescription[EheimDigitalFilter], ...] = (
+    EheimDigitalTimeDescription[EheimDigitalFilter](
+        key="day_start_time",
+        translation_key="day_start_time",
+        entity_category=EntityCategory.CONFIG,
+        value_fn=lambda device: device.day_start_time,
+        set_value_fn=lambda device, value: device.set_day_start_time(value),
+    ),
+    EheimDigitalTimeDescription[EheimDigitalFilter](
+        key="night_start_time",
+        translation_key="night_start_time",
+        entity_category=EntityCategory.CONFIG,
+        value_fn=lambda device: device.night_start_time,
+        set_value_fn=lambda device, value: device.set_night_start_time(value),
+    ),
+)
+
 CLASSICVARIO_DESCRIPTIONS: tuple[
     EheimDigitalTimeDescription[EheimDigitalClassicVario], ...
 ] = (
@@ -79,6 +97,13 @@ async def async_setup_entry(
         """Set up the time entities for one or multiple devices."""
         entities: list[EheimDigitalTime[Any]] = []
         for device in device_address.values():
+            if isinstance(device, EheimDigitalFilter):
+                entities.extend(
+                    EheimDigitalTime[EheimDigitalFilter](
+                        coordinator, device, description
+                    )
+                    for description in FILTER_DESCRIPTIONS
+                )
             if isinstance(device, EheimDigitalClassicVario):
                 entities.extend(
                     EheimDigitalTime[EheimDigitalClassicVario](

homeassistant/components/energy/data.py

@@ -59,38 +59,13 @@ class FlowToGridSourceType(TypedDict):
     number_energy_price: float | None  # Price for energy ($/kWh)
 
 
-class PowerConfig(TypedDict, total=False):
-    """Dictionary holding power sensor configuration options.
-
-    Users can configure power sensors in three ways:
-    1. Standard: single sensor (positive=discharge/from_grid, negative=charge/to_grid)
-    2. Inverted: single sensor with opposite polarity (needs to be multiplied by -1)
-    3. Two sensors: separate positive sensors for each direction
-    """
-
-    # Standard: single sensor (positive=discharge/from_grid, negative=charge/to_grid)
-    stat_rate: str
-
-    # Inverted: single sensor with opposite polarity (needs to be multiplied by -1)
-    stat_rate_inverted: str
-
-    # Two sensors: separate positive sensors for each direction
-    # Result = stat_rate_from - stat_rate_to (positive when net outflow)
-    stat_rate_from: str  # Battery: discharge, Grid: consumption
-    stat_rate_to: str  # Battery: charge, Grid: return
-
-
-class GridPowerSourceType(TypedDict, total=False):
+class GridPowerSourceType(TypedDict):
     """Dictionary holding the source of grid power consumption."""
 
     # statistic_id of a power meter (kW)
     # negative values indicate grid return
-    # This is either the original sensor or a generated template sensor
     stat_rate: str
 
-    # User's original power sensor configuration
-    power_config: PowerConfig
-
 
 class GridSourceType(TypedDict):
     """Dictionary holding the source of grid energy consumption."""
@@ -122,12 +97,8 @@ class BatterySourceType(TypedDict):
     stat_energy_from: str
     stat_energy_to: str
     # positive when discharging, negative when charging
-    # This is either the original sensor or a generated template sensor
     stat_rate: NotRequired[str]
 
-    # User's original power sensor configuration
-    power_config: NotRequired[PowerConfig]
-
 
 class GasSourceType(TypedDict):
     """Dictionary holding the source of gas consumption."""
@@ -240,53 +211,10 @@ FLOW_TO_GRID_SOURCE_SCHEMA = vol.Schema(
     }
 )
 
-
-def _validate_power_config(val: dict[str, Any]) -> dict[str, Any]:
-    """Validate power_config has exactly one configuration method."""
-    if not val:
-        raise vol.Invalid("power_config must have at least one option")
-
-    # Ensure only one configuration method is used
-    has_single = "stat_rate" in val
-    has_inverted = "stat_rate_inverted" in val
-    has_combined = "stat_rate_from" in val or "stat_rate_to" in val
-
-    methods_count = sum([has_single, has_inverted, has_combined])
-    if methods_count > 1:
-        raise vol.Invalid(
-            "power_config must use only one configuration method: "
-            "stat_rate, stat_rate_inverted, or stat_rate_from/stat_rate_to"
-        )
-
-    return val
-
-
-POWER_CONFIG_SCHEMA = vol.All(
-    vol.Schema(
-        {
-            vol.Exclusive("stat_rate", "power_source"): str,
-            vol.Exclusive("stat_rate_inverted", "power_source"): str,
-            # stat_rate_from/stat_rate_to: two sensors for bidirectional power
-            # Battery: from=discharge (out), to=charge (in)
-            # Grid: from=consumption, to=return
-            vol.Inclusive("stat_rate_from", "two_sensors"): str,
-            vol.Inclusive("stat_rate_to", "two_sensors"): str,
-        }
-    ),
-    _validate_power_config,
-)
-
-
-GRID_POWER_SOURCE_SCHEMA = vol.All(
-    vol.Schema(
-        {
-            # stat_rate and power_config are both optional schema keys, but the validator
-            # requires that at least one is provided; power_config takes precedence
-            vol.Optional("stat_rate"): str,
-            vol.Optional("power_config"): POWER_CONFIG_SCHEMA,
-        }
-    ),
-    cv.has_at_least_one_key("stat_rate", "power_config"),
+GRID_POWER_SOURCE_SCHEMA = vol.Schema(
+    {
+        vol.Required("stat_rate"): str,
+    }
 )
 
 
@@ -297,7 +225,7 @@ def _generate_unique_value_validator(key: str) -> Callable[[list[dict]], list[di
         val: list[dict],
     ) -> list[dict]:
         """Ensure that the user doesn't add duplicate values."""
-        counts = Counter(item.get(key) for item in val if item.get(key) is not None)
+        counts = Counter(flow_from[key] for flow_from in val)
 
         for value, count in counts.items():
             if count > 1:
@@ -339,10 +267,7 @@ BATTERY_SOURCE_SCHEMA = vol.Schema(
         vol.Required("type"): "battery",
         vol.Required("stat_energy_from"): str,
         vol.Required("stat_energy_to"): str,
-        # Both stat_rate and power_config are optional
-        # If power_config is provided, it takes precedence and stat_rate is overwritten
         vol.Optional("stat_rate"): str,
-        vol.Optional("power_config"): POWER_CONFIG_SCHEMA,
     }
 )
 GAS_SOURCE_SCHEMA = vol.Schema(
@@ -462,12 +387,6 @@ class EnergyManager:
             if key in update:
                 data[key] = update[key]
 
-        # Process energy sources and set stat_rate for power configs
-        if "energy_sources" in update:
-            data["energy_sources"] = self._process_energy_sources(
-                data["energy_sources"]
-            )
-
         self.data = data
         self._store.async_delay_save(lambda: data, 60)
 
@@ -476,74 +395,6 @@ class EnergyManager:
 
         await asyncio.gather(*(listener() for listener in self._update_listeners))
 
-    def _process_energy_sources(self, sources: list[SourceType]) -> list[SourceType]:
-        """Process energy sources and set stat_rate for power configs."""
-        from .helpers import generate_power_sensor_entity_id  # noqa: PLC0415
-
-        processed: list[SourceType] = []
-        for source in sources:
-            if source["type"] == "battery":
-                source = self._process_battery_power(
-                    source, generate_power_sensor_entity_id
-                )
-            elif source["type"] == "grid":
-                source = self._process_grid_power(
-                    source, generate_power_sensor_entity_id
-                )
-            processed.append(source)
-        return processed
-
-    def _process_battery_power(
-        self,
-        source: BatterySourceType,
-        generate_entity_id: Callable[[str, PowerConfig], str | None],
-    ) -> BatterySourceType:
-        """Set stat_rate for battery if power_config is specified."""
-        if "power_config" not in source:
-            return source
-
-        config = source["power_config"]
-
-        # If power_config has stat_rate (standard), just use it directly
-        if "stat_rate" in config:
-            return {**source, "stat_rate": config["stat_rate"]}
-
-        # For inverted or two-sensor config, set stat_rate to the generated entity_id
-        entity_id = generate_entity_id("battery", config)
-        if entity_id:
-            return {**source, "stat_rate": entity_id}
-
-        return source
-
-    def _process_grid_power(
-        self,
-        source: GridSourceType,
-        generate_entity_id: Callable[[str, PowerConfig], str | None],
-    ) -> GridSourceType:
-        """Set stat_rate for grid power sources if power_config is specified."""
-        if "power" not in source:
-            return source
-
-        processed_power: list[GridPowerSourceType] = []
-        for power in source["power"]:
-            if "power_config" in power:
-                config = power["power_config"]
-
-                # If power_config has stat_rate (standard), just use it directly
-                if "stat_rate" in config:
-                    processed_power.append({**power, "stat_rate": config["stat_rate"]})
-                    continue
-
-                # For inverted or two-sensor config, set stat_rate to generated entity_id
-                entity_id = generate_entity_id("grid", config)
-                if entity_id:
-                    processed_power.append({**power, "stat_rate": entity_id})
-                    continue
-
-            processed_power.append(power)
-
-        return {**source, "power": processed_power}
-
     @callback
     def async_listen_updates(self, update_listener: Callable[[], Awaitable]) -> None:
         """Listen for data updates."""

homeassistant/components/energy/helpers.py

@@ -1,42 +0,0 @@
-"""Helpers for the Energy integration."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .data import PowerConfig
-
-
-def generate_power_sensor_unique_id(
-    source_type: str, config: PowerConfig
-) -> str | None:
-    """Generate a unique ID for a power transform sensor."""
-    if "stat_rate_inverted" in config:
-        sensor_id = config["stat_rate_inverted"].replace(".", "_")
-        return f"energy_power_{source_type}_inverted_{sensor_id}"
-    if "stat_rate_from" in config and "stat_rate_to" in config:
-        from_id = config["stat_rate_from"].replace(".", "_")
-        to_id = config["stat_rate_to"].replace(".", "_")
-        return f"energy_power_{source_type}_combined_{from_id}_{to_id}"
-    return None
-
-
-def generate_power_sensor_entity_id(
-    source_type: str, config: PowerConfig
-) -> str | None:
-    """Generate an entity ID for a power transform sensor."""
-    if "stat_rate_inverted" in config:
-        # Use source sensor name with _inverted suffix
-        source = config["stat_rate_inverted"]
-        if source.startswith("sensor."):
-            return f"{source}_inverted"
-        return f"sensor.{source.replace('.', '_')}_inverted"
-    if "stat_rate_from" in config and "stat_rate_to" in config:
-        # Use both sensors in entity ID to ensure uniqueness when multiple
-        # combined configs exist. The entity represents net power (from - to),
-        # e.g., discharge - charge for battery.
-        from_sensor = config["stat_rate_from"].removeprefix("sensor.")
-        to_sensor = config["stat_rate_to"].removeprefix("sensor.")
-        return f"sensor.energy_{source_type}_{from_sensor}_{to_sensor}_net_power"
-    return None

homeassistant/components/energy/sensor.py

@@ -19,12 +19,7 @@ from homeassistant.components.sensor import (
 from homeassistant.components.sensor.recorder import (  # pylint: disable=hass-component-root-import
     reset_detected,
 )
-from homeassistant.const import (
-    ATTR_UNIT_OF_MEASUREMENT,
-    UnitOfEnergy,
-    UnitOfPower,
-    UnitOfVolume,
-)
+from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, UnitOfEnergy, UnitOfVolume
 from homeassistant.core import (
     HomeAssistant,
     State,
@@ -41,8 +36,7 @@ from homeassistant.util import dt as dt_util, unit_conversion
 from homeassistant.util.unit_system import METRIC_SYSTEM
 
 from .const import DOMAIN
-from .data import EnergyManager, PowerConfig, async_get_manager
-from .helpers import generate_power_sensor_entity_id, generate_power_sensor_unique_id
+from .data import EnergyManager, async_get_manager
 
 SUPPORTED_STATE_CLASSES = {
     SensorStateClass.MEASUREMENT,
@@ -143,7 +137,6 @@ class SensorManager:
         self.manager = manager
         self.async_add_entities = async_add_entities
         self.current_entities: dict[tuple[str, str | None, str], EnergyCostSensor] = {}
-        self.current_power_entities: dict[str, EnergyPowerSensor] = {}
 
     async def async_start(self) -> None:
         """Start."""
@@ -154,9 +147,8 @@ class SensorManager:
 
     async def _process_manager_data(self) -> None:
         """Process manager data."""
-        to_add: list[EnergyCostSensor | EnergyPowerSensor] = []
+        to_add: list[EnergyCostSensor] = []
         to_remove = dict(self.current_entities)
-        power_to_remove = dict(self.current_power_entities)
 
         async def finish() -> None:
             if to_add:
@@ -167,10 +159,6 @@ class SensorManager:
                 self.current_entities.pop(key)
                 await entity.async_remove()
 
-            for power_key, power_entity in power_to_remove.items():
-                self.current_power_entities.pop(power_key)
-                await power_entity.async_remove()
-
         if not self.manager.data:
             await finish()
             return
@@ -197,13 +185,6 @@ class SensorManager:
                         to_remove,
                     )
 
-            # Process power sensors for battery and grid sources
-            self._process_power_sensor_data(
-                energy_source,
-                to_add,
-                power_to_remove,
-            )
-
         await finish()
 
     @callback
@@ -211,7 +192,7 @@ class SensorManager:
         self,
         adapter: SourceAdapter,
         config: Mapping[str, Any],
-        to_add: list[EnergyCostSensor | EnergyPowerSensor],
+        to_add: list[EnergyCostSensor],
         to_remove: dict[tuple[str, str | None, str], EnergyCostSensor],
     ) -> None:
         """Process sensor data."""
@@ -239,74 +220,6 @@ class SensorManager:
         )
         to_add.append(self.current_entities[key])
 
-    @callback
-    def _process_power_sensor_data(
-        self,
-        energy_source: Mapping[str, Any],
-        to_add: list[EnergyCostSensor | EnergyPowerSensor],
-        to_remove: dict[str, EnergyPowerSensor],
-    ) -> None:
-        """Process power sensor data for battery and grid sources."""
-        source_type = energy_source.get("type")
-
-        if source_type == "battery":
-            power_config = energy_source.get("power_config")
-            if power_config and self._needs_power_sensor(power_config):
-                self._create_or_keep_power_sensor(
-                    source_type, power_config, to_add, to_remove
-                )
-
-        elif source_type == "grid":
-            for power in energy_source.get("power", []):
-                power_config = power.get("power_config")
-                if power_config and self._needs_power_sensor(power_config):
-                    self._create_or_keep_power_sensor(
-                        source_type, power_config, to_add, to_remove
-                    )
-
-    @staticmethod
-    def _needs_power_sensor(power_config: PowerConfig) -> bool:
-        """Check if power_config needs a transform sensor."""
-        # Only create sensors for inverted or two-sensor configs
-        # Standard stat_rate configs don't need a transform sensor
-        return "stat_rate_inverted" in power_config or (
-            "stat_rate_from" in power_config and "stat_rate_to" in power_config
-        )
-
-    def _create_or_keep_power_sensor(
-        self,
-        source_type: str,
-        power_config: PowerConfig,
-        to_add: list[EnergyCostSensor | EnergyPowerSensor],
-        to_remove: dict[str, EnergyPowerSensor],
-    ) -> None:
-        """Create a power sensor or keep an existing one."""
-        unique_id = generate_power_sensor_unique_id(source_type, power_config)
-        if not unique_id:
-            return
-
-        # If entity already exists, keep it
-        if unique_id in to_remove:
-            to_remove.pop(unique_id)
-            return
-
-        # If we already have this entity, skip
-        if unique_id in self.current_power_entities:
-            return
-
-        entity_id = generate_power_sensor_entity_id(source_type, power_config)
-        if not entity_id:
-            return
-
-        sensor = EnergyPowerSensor(
-            source_type,
-            power_config,
-            unique_id,
-            entity_id,
-        )
-        self.current_power_entities[unique_id] = sensor
-        to_add.append(sensor)
-
 
 def _set_result_unless_done(future: asyncio.Future[None]) -> None:
     """Set the result of a future unless it is done."""
@@ -582,197 +495,3 @@ class EnergyCostSensor(SensorEntity):
             prefix = self._config[self._adapter.stat_energy_key]
 
         return f"{prefix}_{self._adapter.source_type}_{self._adapter.entity_id_suffix}"
-
-
-class EnergyPowerSensor(SensorEntity):
-    """Transform power sensor values (invert or combine two sensors).
-
-    This sensor handles non-standard power sensor configurations for the energy
-    dashboard by either inverting polarity or combining two positive sensors.
-    """
-
-    _attr_should_poll = False
-    _attr_device_class = SensorDeviceClass.POWER
-    _attr_state_class = SensorStateClass.MEASUREMENT
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        source_type: str,
-        config: PowerConfig,
-        unique_id: str,
-        entity_id: str,
-    ) -> None:
-        """Initialize the sensor."""
-        super().__init__()
-        self._source_type = source_type
-        self._config: PowerConfig = config
-        self._attr_unique_id = unique_id
-        self.entity_id = entity_id
-        self._source_sensors: list[str] = []
-        self._is_inverted = "stat_rate_inverted" in config
-        self._is_combined = "stat_rate_from" in config and "stat_rate_to" in config
-
-        # Determine source sensors
-        if self._is_inverted:
-            self._source_sensors = [config["stat_rate_inverted"]]
-        elif self._is_combined:
-            self._source_sensors = [
-                config["stat_rate_from"],
-                config["stat_rate_to"],
-            ]
-
-        # add_finished is set when either async_added_to_hass or add_to_platform_abort
-        # is called
-        self.add_finished: asyncio.Future[None] = (
-            asyncio.get_running_loop().create_future()
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        if self._is_inverted:
-            source = self.hass.states.get(self._source_sensors[0])
-            return source is not None and source.state not in (
-                "unknown",
-                "unavailable",
-            )
-        if self._is_combined:
-            discharge = self.hass.states.get(self._source_sensors[0])
-            charge = self.hass.states.get(self._source_sensors[1])
-            return (
-                discharge is not None
-                and charge is not None
-                and discharge.state not in ("unknown", "unavailable")
-                and charge.state not in ("unknown", "unavailable")
-            )
-        return True
-
-    @callback
-    def _update_state(self) -> None:
-        """Update the sensor state based on source sensors."""
-        if self._is_inverted:
-            source_state = self.hass.states.get(self._source_sensors[0])
-            if source_state is None or source_state.state in ("unknown", "unavailable"):
-                self._attr_native_value = None
-                return
-            try:
-                value = float(source_state.state)
-            except ValueError:
-                self._attr_native_value = None
-                return
-
-            self._attr_native_value = value * -1
-
-        elif self._is_combined:
-            discharge_state = self.hass.states.get(self._source_sensors[0])
-            charge_state = self.hass.states.get(self._source_sensors[1])
-
-            if (
-                discharge_state is None
-                or charge_state is None
-                or discharge_state.state in ("unknown", "unavailable")
-                or charge_state.state in ("unknown", "unavailable")
-            ):
-                self._attr_native_value = None
-                return
-
-            try:
-                discharge = float(discharge_state.state)
-                charge = float(charge_state.state)
-            except ValueError:
-                self._attr_native_value = None
-                return
-
-            # Get units from state attributes
-            discharge_unit = discharge_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
-            charge_unit = charge_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
-
-            # Convert to Watts if units are present
-            if discharge_unit:
-                discharge = unit_conversion.PowerConverter.convert(
-                    discharge, discharge_unit, UnitOfPower.WATT
-                )
-            if charge_unit:
-                charge = unit_conversion.PowerConverter.convert(
-                    charge, charge_unit, UnitOfPower.WATT
-                )
-
-            self._attr_native_value = discharge - charge
-
-    async def async_added_to_hass(self) -> None:
-        """Register callbacks."""
-        # Set name based on source sensor(s)
-        if self._source_sensors:
-            entity_reg = er.async_get(self.hass)
-            device_id = None
-            source_name = None
-            # Check first sensor
-            if source_entry := entity_reg.async_get(self._source_sensors[0]):
-                device_id = source_entry.device_id
-                # For combined mode, always use Watts because we may have different source units; for inverted mode, copy source unit
-                if self._is_combined:
-                    self._attr_native_unit_of_measurement = UnitOfPower.WATT
-                else:
-                    self._attr_native_unit_of_measurement = (
-                        source_entry.unit_of_measurement
-                    )
-                # Get source name from registry
-                source_name = source_entry.name or source_entry.original_name
-            # Assign power sensor to same device as source sensor(s)
-            # Note: We use manual entity registry update instead of _attr_device_info
-            # because device assignment depends on runtime information from the entity
-            # registry (which source sensor has a device). This information isn't
-            # available during __init__, and the entity is already registered before
-            # async_added_to_hass runs, making the standard _attr_device_info pattern
-            # incompatible with this use case.
-            # If first sensor has no device and we have a second sensor, check it
-            if not device_id and len(self._source_sensors) > 1:
-                if source_entry := entity_reg.async_get(self._source_sensors[1]):
-                    device_id = source_entry.device_id
-            # Update entity registry entry with device_id
-            if device_id and (power_entry := entity_reg.async_get(self.entity_id)):
-                entity_reg.async_update_entity(
-                    power_entry.entity_id, device_id=device_id
-                )
-            else:
-                self._attr_has_entity_name = False
-
-            # Set name for inverted mode
-            if self._is_inverted:
-                if source_name:
-                    self._attr_name = f"{source_name} Inverted"
-                else:
-                    # Fall back to entity_id if no name in registry
-                    sensor_name = split_entity_id(self._source_sensors[0])[1].replace(
-                        "_", " "
-                    )
-                    self._attr_name = f"{sensor_name.title()} Inverted"
-
-        # Set name for combined mode
-        if self._is_combined:
-            self._attr_name = f"{self._source_type.title()} Power"
-
-        self._update_state()
-
-        # Track state changes on all source sensors
-        self.async_on_remove(
-            async_track_state_change_event(
-                self.hass,
-                self._source_sensors,
-                self._async_state_changed_listener,
-            )
-        )
-        _set_result_unless_done(self.add_finished)
-
-    @callback
-    def _async_state_changed_listener(self, *_: Any) -> None:
-        """Handle source sensor state changes."""
-        self._update_state()
-        self.async_write_ha_state()
-
-    @callback
-    def add_to_platform_abort(self) -> None:
-        """Abort adding an entity to a platform."""
-        _set_result_unless_done(self.add_finished)
-        super().add_to_platform_abort()

homeassistant/components/enphase_envoy/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
   "quality_scale": "platinum",
-  "requirements": ["pyenphase==2.4.2"],
+  "requirements": ["pyenphase==2.4.3"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/enphase_envoy/sensor.py

@@ -206,7 +206,7 @@ class EnvoyProductionSensorEntityDescription(SensorEntityDescription):
     """Describes an Envoy production sensor entity."""
 
     value_fn: Callable[[EnvoySystemProduction], int]
-    on_phase: str | None
+    on_phase: str | None = None
 
 
 PRODUCTION_SENSORS = (
@@ -219,7 +219,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
         suggested_display_precision=3,
         value_fn=attrgetter("watts_now"),
-        on_phase=None,
     ),
     EnvoyProductionSensorEntityDescription(
         key="daily_production",
@@ -230,7 +229,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=2,
         value_fn=attrgetter("watt_hours_today"),
-        on_phase=None,
     ),
     EnvoyProductionSensorEntityDescription(
         key="seven_days_production",
@@ -240,7 +238,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=1,
         value_fn=attrgetter("watt_hours_last_7_days"),
-        on_phase=None,
     ),
     EnvoyProductionSensorEntityDescription(
         key="lifetime_production",
@@ -251,7 +248,6 @@ PRODUCTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
         suggested_display_precision=3,
         value_fn=attrgetter("watt_hours_lifetime"),
-        on_phase=None,
     ),
 )
 
@@ -277,7 +273,7 @@ class EnvoyConsumptionSensorEntityDescription(SensorEntityDescription):
     """Describes an Envoy consumption sensor entity."""
 
     value_fn: Callable[[EnvoySystemConsumption], int]
-    on_phase: str | None
+    on_phase: str | None = None
 
 
 CONSUMPTION_SENSORS = (
@@ -290,7 +286,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
         suggested_display_precision=3,
         value_fn=attrgetter("watts_now"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="daily_consumption",
@@ -301,7 +296,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=2,
         value_fn=attrgetter("watt_hours_today"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="seven_days_consumption",
@@ -311,7 +305,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=1,
         value_fn=attrgetter("watt_hours_last_7_days"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="lifetime_consumption",
@@ -322,7 +315,6 @@ CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
         suggested_display_precision=3,
         value_fn=attrgetter("watt_hours_lifetime"),
-        on_phase=None,
     ),
 )
 
@@ -354,7 +346,6 @@ NET_CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
         suggested_display_precision=3,
         value_fn=attrgetter("watts_now"),
-        on_phase=None,
     ),
     EnvoyConsumptionSensorEntityDescription(
         key="lifetime_balanced_net_consumption",
@@ -366,7 +357,6 @@ NET_CONSUMPTION_SENSORS = (
         suggested_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         suggested_display_precision=3,
         value_fn=attrgetter("watt_hours_lifetime"),
-        on_phase=None,
     ),
 )
 
@@ -395,7 +385,7 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
         [EnvoyMeterData],
         int | float | str | CtType | CtMeterStatus | CtStatusFlags | CtState | None,
     ]
-    on_phase: str | None
+    on_phase: str | None = None
     cttype: str | None = None
 
 
@@ -411,7 +401,6 @@ CT_SENSORS = (
             suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
             suggested_display_precision=3,
             value_fn=attrgetter("energy_delivered"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -430,7 +419,6 @@ CT_SENSORS = (
             suggested_unit_of_measurement=UnitOfEnergy.MEGA_WATT_HOUR,
             suggested_display_precision=3,
             value_fn=attrgetter("energy_received"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -449,7 +437,6 @@ CT_SENSORS = (
             suggested_unit_of_measurement=UnitOfPower.KILO_WATT,
             suggested_display_precision=3,
             value_fn=attrgetter("active_power"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -468,7 +455,6 @@ CT_SENSORS = (
             suggested_display_precision=1,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("frequency"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -488,7 +474,6 @@ CT_SENSORS = (
             suggested_display_precision=1,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("voltage"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -508,7 +493,6 @@ CT_SENSORS = (
             suggested_display_precision=3,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("current"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -526,7 +510,6 @@ CT_SENSORS = (
             suggested_display_precision=2,
             entity_registry_enabled_default=False,
             value_fn=attrgetter("power_factor"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key in (
@@ -544,7 +527,6 @@ CT_SENSORS = (
             options=list(CtMeterStatus),
             entity_registry_enabled_default=False,
             value_fn=attrgetter("metering_status"),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -565,7 +547,6 @@ CT_SENSORS = (
             entity_category=EntityCategory.DIAGNOSTIC,
             entity_registry_enabled_default=False,
             value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
-            on_phase=None,
             cttype=cttype,
         )
         for cttype, key, translation_key in (
@@ -783,7 +764,7 @@ ENCHARGE_AGGREGATE_SENSORS = (
         translation_key="available_energy",
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.ENERGY,
+        device_class=SensorDeviceClass.ENERGY_STORAGE,
         value_fn=attrgetter("available_energy"),
     ),
     EnvoyEnchargeAggregateSensorEntityDescription(
@@ -791,14 +772,14 @@ ENCHARGE_AGGREGATE_SENSORS = (
         translation_key="reserve_energy",
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
         state_class=SensorStateClass.MEASUREMENT,
-        device_class=SensorDeviceClass.ENERGY,
+        device_class=SensorDeviceClass.ENERGY_STORAGE,
         value_fn=attrgetter("backup_reserve"),
     ),
     EnvoyEnchargeAggregateSensorEntityDescription(
         key="max_capacity",
         translation_key="max_capacity",
         native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
-        device_class=SensorDeviceClass.ENERGY,
+        device_class=SensorDeviceClass.ENERGY_STORAGE,
         value_fn=attrgetter("max_available_capacity"),
     ),
 )

homeassistant/components/envisalink/binary_sensor.py

@@ -5,7 +5,10 @@ from __future__ import annotations
 import datetime
 import logging
 
-from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+)
 from homeassistant.const import ATTR_LAST_TRIP_TIME
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -102,7 +105,7 @@ class EnvisalinkBinarySensor(EnvisalinkEntity, BinarySensorEntity):
         return self._info["status"]["open"]
 
     @property
-    def device_class(self):
+    def device_class(self) -> BinarySensorDeviceClass:
         """Return the class of this sensor, from DEVICE_CLASSES."""
         return self._zone_type
 

homeassistant/components/facebook/notify.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from http import HTTPStatus
 import json
 import logging
+from typing import Any
 
 import requests
 import voluptuous as vol
@@ -46,7 +47,7 @@ class FacebookNotificationService(BaseNotificationService):
         """Initialize the service."""
         self.page_access_token = access_token
 
-    def send_message(self, message="", **kwargs):
+    def send_message(self, message: str = "", **kwargs: Any) -> None:
         """Send some message."""
         payload = {"access_token": self.page_access_token}
         targets = kwargs.get(ATTR_TARGET)

homeassistant/components/fan/condition.py

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

homeassistant/components/fan/conditions.yaml

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

homeassistant/components/fan/icons.json

@@ -1,4 +1,12 @@
 {
+  "conditions": {
+    "is_off": {
+      "condition": "mdi:fan-off"
+    },
+    "is_on": {
+      "condition": "mdi:fan"
+    }
+  },
   "entity_component": {
     "_": {
       "default": "mdi:fan",

homeassistant/components/fan/strings.json

@@ -1,8 +1,32 @@
 {
   "common": {
+    "condition_behavior_description": "How the state should match on the targeted fans.",
+    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted fans to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
+  "conditions": {
+    "is_off": {
+      "description": "Tests if one or more fans are off.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::fan::common::condition_behavior_description%]",
+          "name": "[%key:component::fan::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If a fan is off"
+    },
+    "is_on": {
+      "description": "Tests if one or more fans are on.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::fan::common::condition_behavior_description%]",
+          "name": "[%key:component::fan::common::condition_behavior_name%]"
+        }
+      },
+      "name": "If a fan is on"
+    }
+  },
   "device_automation": {
     "action_type": {
       "toggle": "[%key:common::device_automation::action_type::toggle%]",
@@ -65,6 +89,12 @@
     }
   },
   "selector": {
+    "condition_behavior": {
+      "options": {
+        "all": "All",
+        "any": "Any"
+      }
+    },
     "direction": {
       "options": {
         "forward": "Forward",

homeassistant/components/firefly_iii/coordinator.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 import logging
@@ -97,17 +98,30 @@ class FireflyDataUpdateCoordinator(DataUpdateCoordinator[FireflyCoordinatorData]
         end_date = now
 
         try:
-            accounts = await self.firefly.get_accounts()
-            categories = await self.firefly.get_categories()
-            category_details = [
-                await self.firefly.get_category(
-                    category_id=int(category.id), start=start_date, end=end_date
+            (
+                accounts,
+                categories,
+                primary_currency,
+                budgets,
+                bills,
+            ) = await asyncio.gather(
+                self.firefly.get_accounts(),
+                self.firefly.get_categories(),
+                self.firefly.get_currency_primary(),
+                self.firefly.get_budgets(start=start_date, end=end_date),
+                self.firefly.get_bills(),
+            )
+
+            category_details = await asyncio.gather(
+                *(
+                    self.firefly.get_category(
+                        category_id=int(category.id),
+                        start=start_date,
+                        end=end_date,
+                    )
+                    for category in categories
                 )
-                for category in categories
-            ]
-            primary_currency = await self.firefly.get_currency_primary()
-            budgets = await self.firefly.get_budgets(start=start_date, end=end_date)
-            bills = await self.firefly.get_bills()
+            )
         except FireflyAuthenticationError as err:
             raise ConfigEntryAuthFailed(
                 translation_domain=DOMAIN,

homeassistant/components/firefly_iii/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["pyfirefly==0.1.10"]
+  "requirements": ["pyfirefly==0.1.11"]
 }

homeassistant/components/fitbit/sensor.py

@@ -461,7 +461,7 @@ FITBIT_RESOURCES_LIST: Final[tuple[FitbitSensorEntityDescription, ...]] = (
         key="sleep/timeInBed",
         translation_key="sleep_time_in_bed",
         native_unit_of_measurement=UnitOfTime.MINUTES,
-        icon="mdi:hotel",
+        icon="mdi:bed",
         device_class=SensorDeviceClass.DURATION,
         scope=FitbitScope.SLEEP,
         state_class=SensorStateClass.TOTAL_INCREASING,

homeassistant/components/flock/notify.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 from http import HTTPStatus
 import logging
+from typing import Any
 
 import voluptuous as vol
 
@@ -47,7 +48,7 @@ class FlockNotificationService(BaseNotificationService):
         self._url = url
         self._session = session
 
-    async def async_send_message(self, message, **kwargs):
+    async def async_send_message(self, message: str, **kwargs: Any) -> None:
         """Send the message to the user."""
         payload = {"text": message}
 

homeassistant/components/free_mobile/notify.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from http import HTTPStatus
 import logging
+from typing import Any
 
 from freesms import FreeClient
 import voluptuous as vol
@@ -40,7 +41,7 @@ class FreeSMSNotificationService(BaseNotificationService):
         """Initialize the service."""
         self.free_client = FreeClient(username, access_token)
 
-    def send_message(self, message="", **kwargs):
+    def send_message(self, message: str = "", **kwargs: Any) -> None:
         """Send a message to the Free Mobile user cell."""
         resp = self.free_client.send_sms(message)
 

homeassistant/components/fressnapf_tracker/config_flow.py

@@ -31,7 +31,7 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
 )
 STEP_SMS_CODE_DATA_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_SMS_CODE): int,
+        vol.Required(CONF_SMS_CODE): str,
     }
 )
 
@@ -75,7 +75,7 @@ class FressnapfTrackerConfigFlow(ConfigFlow, domain=DOMAIN):
         return errors, False
 
     async def _async_verify_sms_code(
-        self, sms_code: int
+        self, sms_code: str
     ) -> tuple[dict[str, str], str | None]:
         """Verify SMS code and return errors and access_token."""
         errors: dict[str, str] = {}

homeassistant/components/fressnapf_tracker/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["fressnapftracker==0.2.0"]
+  "requirements": ["fressnapftracker==0.2.1"]
 }

homeassistant/components/fritz/button.py

@@ -164,13 +164,12 @@ def _async_wol_buttons_list(
 class FritzBoxWOLButton(FritzDeviceBase, ButtonEntity):
     """Defines a FRITZ!Box Tools Wake On LAN button."""
 
-    _attr_icon = "mdi:lan-pending"
     _attr_entity_registry_enabled_default = False
+    _attr_translation_key = "wake_on_lan"
 
     def __init__(self, avm_wrapper: AvmWrapper, device: FritzDevice) -> None:
         """Initialize Fritz!Box WOL button."""
         super().__init__(avm_wrapper, device)
-        self._name = f"{self.hostname} Wake on LAN"
         self._attr_unique_id = f"{self._mac}_wake_on_lan"
         self._is_available = True
 

homeassistant/components/fritz/device_tracker.py

@@ -10,6 +10,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
+from .const import DEFAULT_DEVICE_NAME
 from .coordinator import FRITZ_DATA_KEY, AvmWrapper, FritzConfigEntry, FritzData
 from .entity import FritzDeviceBase
 from .helpers import device_filter_out_from_trackers
@@ -71,6 +72,7 @@ class FritzBoxTracker(FritzDeviceBase, ScannerEntity):
     def __init__(self, avm_wrapper: AvmWrapper, device: FritzDevice) -> None:
         """Initialize a FRITZ!Box device."""
         super().__init__(avm_wrapper, device)
+        self._attr_name: str = device.hostname or DEFAULT_DEVICE_NAME
         self._last_activity: datetime.datetime | None = device.last_activity
 
     @property

homeassistant/components/fritz/entity.py

@@ -13,7 +13,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DEFAULT_DEVICE_NAME, DOMAIN
+from .const import DOMAIN
 from .coordinator import AvmWrapper
 from .models import FritzDevice
 
@@ -21,21 +21,17 @@ from .models import FritzDevice
 class FritzDeviceBase(CoordinatorEntity[AvmWrapper]):
     """Entity base class for a device connected to a FRITZ!Box device."""
 
+    _attr_has_entity_name = True
+
     def __init__(self, avm_wrapper: AvmWrapper, device: FritzDevice) -> None:
         """Initialize a FRITZ!Box device."""
         super().__init__(avm_wrapper)
         self._avm_wrapper = avm_wrapper
         self._mac: str = device.mac_address
-        self._name: str = device.hostname or DEFAULT_DEVICE_NAME
         self._attr_device_info = DeviceInfo(
             connections={(dr.CONNECTION_NETWORK_MAC, device.mac_address)}
         )
 
-    @property
-    def name(self) -> str:
-        """Return device name."""
-        return self._name
-
     @property
     def ip_address(self) -> str | None:
         """Return the primary ip address of the device."""

homeassistant/components/fritz/icons.json

@@ -3,6 +3,9 @@
     "button": {
       "cleanup": {
         "default": "mdi:broom"
+      },
+      "wake_on_lan": {
+        "default": "mdi:lan-pending"
       }
     },
     "sensor": {
@@ -48,6 +51,11 @@
       "max_kb_s_sent": {
         "default": "mdi:upload"
       }
+    },
+    "switch": {
+      "internet_access": {
+        "default": "mdi:router-wireless-settings"
+      }
     }
   },
   "services": {

homeassistant/components/fritz/manifest.json

@@ -8,6 +8,7 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["fritzconnection"],
+  "quality_scale": "bronze",
   "requirements": ["fritzconnection[qr]==1.15.0", "xmltodict==1.0.2"],
   "ssdp": [
     {

homeassistant/components/fritz/quality_scale.yaml

@@ -13,9 +13,7 @@ rules:
   docs-removal-instructions: done
   entity-event-setup: done
   entity-unique-id: done
-  has-entity-name:
-    status: todo
-    comment: partially done
+  has-entity-name: done
   runtime-data: done
   test-before-configure: done
   test-before-setup: done

homeassistant/components/fritz/strings.json

@@ -108,6 +108,9 @@
       },
       "reconnect": {
         "name": "Reconnect"
+      },
+      "wake_on_lan": {
+        "name": "Wake on LAN"
       }
     },
     "sensor": {
@@ -162,6 +165,11 @@
       "max_kb_s_sent": {
         "name": "Max connection upload throughput"
       }
+    },
+    "switch": {
+      "internet_access": {
+        "name": "Internet access"
+      }
     }
   },
   "exceptions": {

homeassistant/components/fritz/switch.py

@@ -499,13 +499,12 @@ class FritzBoxDeflectionSwitch(FritzBoxBaseCoordinatorSwitch):
 class FritzBoxProfileSwitch(FritzDeviceBase, SwitchEntity):
     """Defines a FRITZ!Box Tools DeviceProfile switch."""
 
-    _attr_icon = "mdi:router-wireless-settings"
+    _attr_translation_key = "internet_access"
 
     def __init__(self, avm_wrapper: AvmWrapper, device: FritzDevice) -> None:
         """Init Fritz profile."""
         super().__init__(avm_wrapper, device)
         self._attr_is_on: bool = False
-        self._name = f"{device.hostname} Internet Access"
         self._attr_unique_id = f"{self._mac}_internet_access"
         self._attr_entity_category = EntityCategory.CONFIG
 

homeassistant/components/fritzbox/coordinator.py

@@ -77,9 +77,14 @@ class FritzboxDataUpdateCoordinator(DataUpdateCoordinator[FritzboxCoordinatorDat
         )
         LOGGER.debug("enable smarthome templates: %s", self.has_templates)
 
-        self.has_triggers = await self.hass.async_add_executor_job(
-            self.fritz.has_triggers
-        )
+        try:
+            self.has_triggers = await self.hass.async_add_executor_job(
+                self.fritz.has_triggers
+            )
+        except HTTPError:
+            # Fritz!OS < 7.39 just don't have this api endpoint
+            # so we need to fetch the HTTPError here and assume no triggers
+            self.has_triggers = False
         LOGGER.debug("enable smarthome triggers: %s", self.has_triggers)
 
         self.configuration_url = self.fritz.get_prefixed_host()

homeassistant/components/frontend/manifest.json

@@ -23,5 +23,5 @@
     "winter_mode": {}
   },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251229.1"]
+  "requirements": ["home-assistant-frontend==20260107.1"]
 }

homeassistant/components/generic_thermostat/climate.py

@@ -66,6 +66,7 @@ from .const import (
     CONF_COLD_TOLERANCE,
     CONF_HEATER,
     CONF_HOT_TOLERANCE,
+    CONF_KEEP_ALIVE,
     CONF_MAX_TEMP,
     CONF_MIN_DUR,
     CONF_MIN_TEMP,
@@ -81,7 +82,6 @@ _LOGGER = logging.getLogger(__name__)
 DEFAULT_NAME = "Generic Thermostat"
 
 CONF_INITIAL_HVAC_MODE = "initial_hvac_mode"
-CONF_KEEP_ALIVE = "keep_alive"
 CONF_PRECISION = "precision"
 CONF_TARGET_TEMP = "target_temp"
 CONF_TEMP_STEP = "target_temp_step"

homeassistant/components/generic_thermostat/config_flow.py

@@ -21,6 +21,7 @@ from .const import (
     CONF_COLD_TOLERANCE,
     CONF_HEATER,
     CONF_HOT_TOLERANCE,
+    CONF_KEEP_ALIVE,
     CONF_MAX_TEMP,
     CONF_MIN_DUR,
     CONF_MIN_TEMP,
@@ -59,6 +60,9 @@ OPTIONS_SCHEMA = {
     vol.Optional(CONF_MIN_DUR): selector.DurationSelector(
         selector.DurationSelectorConfig(allow_negative=False)
     ),
+    vol.Optional(CONF_KEEP_ALIVE): selector.DurationSelector(
+        selector.DurationSelectorConfig(allow_negative=False)
+    ),
     vol.Optional(CONF_MIN_TEMP): selector.NumberSelector(
         selector.NumberSelectorConfig(
             mode=selector.NumberSelectorMode.BOX, unit_of_measurement=DEGREE, step=0.1