Remove show_advanced_options from data entry flow API (#172249)

Co-authored-by: Norbert Rittel <norbert@rittel.de>
Co-authored-by: Philippe Lafoucrière <12752+gravis@users.noreply.github.com>
Co-authored-by: Joost Lekkerkerker <joostlek@outlook.com>
Co-authored-by: Robert Resch <robert@resch.dev>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Ariel Ebersberger <ariel@ebersberger.io>

.github/actions/cache-apt-packages/action.yml

@@ -0,0 +1,52 @@
+name: Cache and install APT packages
+description: >-
+  Wraps awalsh128/cache-apt-pkgs-action with the workarounds Home Assistant CI
+  needs. Removes the conflicting Microsoft apt source before any apt run, and
+  points the dynamic linker at the host's multiarch lib subdirectories so
+  shared libraries that rely on update-alternatives or postinst-managed paths
+  (eg libblas, liblapack pulled in by ffmpeg) stay reachable since the upstream
+  action does not execute postinst scripts on cache restore.
+
+inputs:
+  packages:
+    description: Space-delimited list of apt packages to install.
+    required: true
+  version:
+    description: Cache version. Bump to invalidate the cache.
+    required: false
+    default: "1"
+  execute_install_scripts:
+    description: >-
+      Pass-through to awalsh128/cache-apt-pkgs-action. Postinst scripts are not
+      actually cached by the upstream action, so this is largely a no-op today.
+    required: false
+    default: "false"
+
+runs:
+  using: composite
+  steps:
+    - name: Remove conflicting Microsoft apt source
+      shell: bash
+      run: sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list
+    - name: Install apt packages via cache
+      uses: awalsh128/cache-apt-pkgs-action@acb598e5ddbc6f68a970c5da0688d2f3a9f04d05 # v1.5.3
+      with:
+        packages: ${{ inputs.packages }}
+        version: ${{ inputs.version }}
+        execute_install_scripts: ${{ inputs.execute_install_scripts }}
+    - name: Refresh dynamic linker cache
+      shell: bash
+      run: |
+        # awalsh128/cache-apt-pkgs-action does not run postinst scripts on
+        # cache restore, so update-alternatives symlinks (eg the one libblas
+        # creates at /usr/lib/<multiarch>/libblas.so.3) are never produced.
+        # Add every /usr/lib/<multiarch> subdirectory that holds shared
+        # libraries to the ldconfig search path so the dynamic linker still
+        # finds them.  Use dpkg-architecture to derive the host's multiarch
+        # tuple so this works on non-x86_64 runners too.
+        multiarch="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
+        find "/usr/lib/${multiarch}" -mindepth 2 -maxdepth 2 \
+          -name '*.so.*' -printf '%h\n' \
+          | sort -u \
+          | sudo tee /etc/ld.so.conf.d/zzz-cache-apt-extras.conf > /dev/null
+        sudo ldconfig

.github/workflows/ci.yaml

@@ -60,9 +60,7 @@ env:
   # - 15.2 is the latest (as of 9 Feb 2023)
   POSTGRESQL_VERSIONS: "['postgres:12.14','postgres:15.2']"
   UV_CACHE_DIR: /tmp/uv-cache
-  APT_CACHE_BASE: /home/runner/work/apt
-  APT_CACHE_DIR: /home/runner/work/apt/cache
-  APT_LIST_CACHE_DIR: /home/runner/work/apt/lists
+  APT_CACHE_VERSION: 1
   SQLALCHEMY_WARN_20: 1
   PYTHONASYNCIODEBUG: 1
   HASS_CI: 1
@@ -86,7 +84,6 @@ jobs:
       core: ${{ steps.core.outputs.changes }}
       integrations_glob: ${{ steps.info.outputs.integrations_glob }}
       integrations: ${{ steps.integrations.outputs.changes }}
-      apt_cache_key: ${{ steps.generate_apt_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 }}
@@ -116,10 +113,6 @@ jobs:
           # Include HA_SHORT_VERSION to force the immediate creation
           # of a new uv cache entry after a version bump.
           echo "key=venv-${CACHE_VERSION}-${HA_SHORT_VERSION}-${HASH_REQUIREMENTS_TEST}-${HASH_REQUIREMENTS}-${HASH_REQUIREMENTS_ALL}-${HASH_PACKAGE_CONSTRAINTS}-${HASH_GEN_REQUIREMENTS}" >> $GITHUB_OUTPUT
-      - name: Generate partial apt restore key
-        id: generate_apt_cache_key
-        run: |
-          echo "key=$(lsb_release -rs)-apt-${CACHE_VERSION}-${HA_SHORT_VERSION}" >> $GITHUB_OUTPUT
       - name: Filter for core changes
         uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
         id: core
@@ -384,65 +377,36 @@ jobs:
           path: ${{ env.UV_CACHE_DIR }}
           key: ${{ steps.generate-uv-key.outputs.full_key }}
           restore-keys: ${{ steps.generate-uv-key.outputs.partial_key }}
-      - name: Check if apt cache exists
-        id: cache-apt-check
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          lookup-only: ${{ steps.cache-venv.outputs.cache-hit == 'true' }}
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
       - name: Install additional OS dependencies
-        if: |
-          steps.cache-venv.outputs.cache-hit != 'true'
-          || steps.cache-apt-check.outputs.cache-hit != 'true'
-        id: install-os-deps
+        if: steps.cache-venv.outputs.cache-hit != 'true'
         timeout-minutes: 10
-        env:
-          APT_CACHE_HIT: ${{ steps.cache-apt-check.outputs.cache-hit }}
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          if [[ "${APT_CACHE_HIT}" != 'true' ]]; then
-            mkdir -p ${APT_CACHE_DIR}
-            mkdir -p ${APT_LIST_CACHE_DIR}
-          fi
-
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils \
-            libavcodec-dev \
-            libavdevice-dev \
-            libavfilter-dev \
-            libavformat-dev \
-            libavutil-dev \
-            libswresample-dev \
-            libswscale-dev \
-            libudev-dev
-
-          if [[ "${APT_CACHE_HIT}" != 'true' ]]; then
-            sudo chmod -R 755 ${APT_CACHE_BASE}
-          fi
-      - name: Save apt cache
-        if: |
-          always()
-          && steps.cache-apt-check.outputs.cache-hit != 'true'
-          && steps.install-os-deps.outcome == 'success'
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: ./.github/actions/cache-apt-packages
         with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+            libavcodec-dev
+            libavdevice-dev
+            libavfilter-dev
+            libavformat-dev
+            libavutil-dev
+            libswresample-dev
+            libswscale-dev
+            libudev-dev
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
+      - name: Read uv version from requirements.txt
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        id: read-uv-version
+        run: |
+          echo "version=$(grep '^uv==' requirements.txt | cut -d'=' -f3)" >> "$GITHUB_OUTPUT"
+      - name: Set up uv
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          version: ${{ steps.read-uv-version.outputs.version }}
       - name: Create Python virtual environment
         if: steps.cache-venv.outputs.cache-hit != 'true'
         id: create-venv
@@ -450,8 +414,6 @@ jobs:
           python -m venv venv
           . venv/bin/activate
           python --version
-          pip install "$(grep '^uv' < requirements.txt)"
-          uv pip install -U "pip>=25.2"
           uv pip install -r requirements.txt
           uv pip install -r requirements_all.txt -r requirements_test.txt
           uv pip install -e . --config-settings editable_mode=compat
@@ -506,30 +468,16 @@ jobs:
       && github.event.inputs.mypy-only != 'true'
       && github.event.inputs.audit-licenses-only != 'true'
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            libturbojpeg
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: libturbojpeg
+          version: ${{ env.APT_CACHE_VERSION }}
       - name: Set up Python
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -876,32 +824,20 @@ jobs:
       - info
       - base
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -952,33 +888,21 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         group: ${{ fromJson(needs.info.outputs.test_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1105,34 +1029,22 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         mariadb-group: ${{ fromJson(needs.info.outputs.mariadb_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libmariadb-dev-compat \
-            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libmariadb-dev-compat
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1266,36 +1178,29 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         postgresql-group: ${{ fromJson(needs.info.outputs.postgresql_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils
-          sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
-          sudo apt-get -y install \
-            postgresql-server-dev-14
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
+      - name: Set up PostgreSQL apt repository
+        run: sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
+      - name: Cache PostgreSQL development headers
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: postgresql-server-dev-14
+          version: ${{ env.APT_CACHE_VERSION }}
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1449,33 +1354,21 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         group: ${{ fromJson(needs.info.outputs.test_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0

.strict-typing

@@ -337,6 +337,7 @@ homeassistant.components.led_ble.*
 homeassistant.components.lektrico.*
 homeassistant.components.letpot.*
 homeassistant.components.lg_infrared.*
+homeassistant.components.lg_tv_rs232.*
 homeassistant.components.libre_hardware_monitor.*
 homeassistant.components.lidarr.*
 homeassistant.components.liebherr.*
@@ -428,6 +429,7 @@ homeassistant.components.otp.*
 homeassistant.components.ouman_eh_800.*
 homeassistant.components.overkiz.*
 homeassistant.components.overseerr.*
+homeassistant.components.ovhcloud_ai_endpoints.*
 homeassistant.components.p1_monitor.*
 homeassistant.components.paj_gps.*
 homeassistant.components.panel_custom.*

CODEOWNERS

@@ -987,6 +987,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/lg_netcast/ @Drafteed @splinter98
 /homeassistant/components/lg_thinq/ @LG-ThinQ-Integration
 /tests/components/lg_thinq/ @LG-ThinQ-Integration
+/homeassistant/components/lg_tv_rs232/ @balloob
+/tests/components/lg_tv_rs232/ @balloob
 /homeassistant/components/libre_hardware_monitor/ @Sab44
 /tests/components/libre_hardware_monitor/ @Sab44
 /homeassistant/components/lichess/ @aryanhasgithub
@@ -1290,6 +1292,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/openhome/ @bazwilliams
 /homeassistant/components/openrgb/ @felipecrs
 /tests/components/openrgb/ @felipecrs
+/homeassistant/components/opensensemap/ @AlCalzone
+/tests/components/opensensemap/ @AlCalzone
 /homeassistant/components/opensky/ @joostlek
 /tests/components/opensky/ @joostlek
 /homeassistant/components/opentherm_gw/ @mvn23
@@ -1317,6 +1321,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/overkiz/ @imicknl
 /homeassistant/components/overseerr/ @joostlek @AmGarera
 /tests/components/overseerr/ @joostlek @AmGarera
+/homeassistant/components/ovhcloud_ai_endpoints/ @Crocmagnon
+/tests/components/ovhcloud_ai_endpoints/ @Crocmagnon
 /homeassistant/components/ovo_energy/ @timmo001
 /tests/components/ovo_energy/ @timmo001
 /homeassistant/components/p1_monitor/ @klaasnicolaas
@@ -2048,8 +2054,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/yamaha_musiccast/ @vigonotion @micha91
 /homeassistant/components/yandex_transport/ @rishatik92 @devbis
 /tests/components/yandex_transport/ @rishatik92 @devbis
-/homeassistant/components/yardian/ @h3l1o5
-/tests/components/yardian/ @h3l1o5
+/homeassistant/components/yardian/ @aeon-matrix
+/tests/components/yardian/ @aeon-matrix
 /homeassistant/components/yeelight/ @zewelor @shenxn @starkillerOG @alexyao2015
 /tests/components/yeelight/ @zewelor @shenxn @starkillerOG @alexyao2015
 /homeassistant/components/yeelightsunflower/ @lindsaymarkward

homeassistant/components/alexa_devices/__init__.py

@@ -17,6 +17,7 @@ PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
     Platform.EVENT,
+    Platform.MEDIA_PLAYER,
     Platform.NOTIFY,
     Platform.SENSOR,
     Platform.SWITCH,
@@ -40,6 +41,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bo
     await coordinator.async_config_entry_first_refresh()
 
     await coordinator.sync_history_state()
+    await coordinator.sync_media_state()
 
     async def _on_http2_reauth_required() -> None:
         entry.async_start_reauth(hass)

homeassistant/components/alexa_devices/coordinator.py

@@ -8,7 +8,12 @@ from aioamazondevices.exceptions import (
     CannotConnect,
     CannotRetrieveData,
 )
-from aioamazondevices.structures import AmazonDevice, AmazonVocalRecord
+from aioamazondevices.structures import (
+    AmazonDevice,
+    AmazonMediaState,
+    AmazonVocalRecord,
+    AmazonVolumeState,
+)
 from aiohttp import ClientSession
 
 from homeassistant.config_entries import ConfigEntry
@@ -74,10 +79,17 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
         }
 
         self._vocal_records: dict[str, AmazonVocalRecord] = {}
-
         self.api.on_history_event.append(self.history_state_event_handler)
         self.api.on_history_event.freeze()
 
+        self._volume_states: dict[str, AmazonVolumeState] = {}
+        self.api.on_volume_state_event.append(self.volume_state_event_handler)
+        self.api.on_volume_state_event.freeze()
+
+        self._media_states: dict[str, AmazonMediaState] = {}
+        self.api.on_media_state_event.append(self.media_state_event_handler)
+        self.api.on_media_state_event.freeze()
+
     async def _async_update_data(self) -> dict[str, AmazonDevice]:
         """Update device data."""
         try:
@@ -189,3 +201,31 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
     def vocal_records(self) -> dict[str, AmazonVocalRecord]:
         """Vocal records of devices."""
         return self._vocal_records
+
+    async def sync_media_state(self) -> None:
+        """Sync media state."""
+        await self.api.sync_media_state()
+
+    async def media_state_event_handler(
+        self, media_state: dict[str, AmazonMediaState]
+    ) -> None:
+        """Handle pushed media state changed events."""
+        self._media_states = media_state
+        self.async_update_listeners()
+
+    @property
+    def media_states(self) -> dict[str, AmazonMediaState]:
+        """Media state of devices."""
+        return self._media_states
+
+    async def volume_state_event_handler(
+        self, volume_states: dict[str, AmazonVolumeState]
+    ) -> None:
+        """Handle pushed volume change events."""
+        self._volume_states = volume_states
+        self.async_update_listeners()
+
+    @property
+    def volume_states(self) -> dict[str, AmazonVolumeState]:
+        """Volumes of devices."""
+        return self._volume_states

homeassistant/components/alexa_devices/media_player.py

@@ -0,0 +1,294 @@
+"""Media player platform for Alexa Devices."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Final
+
+from aioamazondevices.structures import (
+    AmazonMediaControls,
+    AmazonMediaState,
+    AmazonVolumeState,
+)
+
+from homeassistant.components.media_player import (
+    MediaPlayerDeviceClass,
+    MediaPlayerEnqueue,
+    MediaPlayerEntity,
+    MediaPlayerEntityDescription,
+    MediaPlayerEntityFeature,
+    MediaPlayerState,
+    MediaType,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import _LOGGER
+from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
+from .entity import AmazonEntity
+from .utils import alexa_api_call
+
+PARALLEL_UPDATES = 1
+
+STANDARD_SUPPORTED_FEATURES = (
+    MediaPlayerEntityFeature.VOLUME_SET
+    | MediaPlayerEntityFeature.VOLUME_STEP
+    | MediaPlayerEntityFeature.VOLUME_MUTE
+    | MediaPlayerEntityFeature.STOP
+    | MediaPlayerEntityFeature.PLAY_MEDIA
+)
+
+
+@dataclass(frozen=True, kw_only=True)
+class AmazonDevicesMediaPlayerEntityDescription(MediaPlayerEntityDescription):
+    """Describes an Alexa Devices media player entity."""
+
+
+MEDIA_PLAYERS: Final = (
+    AmazonDevicesMediaPlayerEntityDescription(
+        key="media",
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AmazonConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Alexa Devices media player entities from a config entry."""
+    coordinator = entry.runtime_data
+
+    known_devices: set[str] = set()
+
+    def _check_device() -> None:
+        """Add entities for newly discovered devices."""
+        new_entities: list[AlexaDevicesMediaPlayer] = []
+
+        for serial_num, device in coordinator.data.items():
+            if serial_num in known_devices or not device.media_player_supported:
+                continue
+
+            known_devices.add(serial_num)
+            new_entities.extend(
+                AlexaDevicesMediaPlayer(coordinator, serial_num, description)
+                for description in MEDIA_PLAYERS
+            )
+
+        if new_entities:
+            async_add_entities(new_entities)
+
+    remove_listener = coordinator.async_add_listener(_check_device)
+    entry.async_on_unload(remove_listener)
+    _check_device()
+
+
+class AlexaDevicesMediaPlayer(AmazonEntity, MediaPlayerEntity):
+    """Representation of an Alexa device media player."""
+
+    entity_description: AmazonDevicesMediaPlayerEntityDescription
+
+    _attr_name = None  # Uses the device name
+    _attr_device_class = MediaPlayerDeviceClass.SPEAKER
+    _attr_volume_step = 0.05
+
+    def __init__(
+        self,
+        coordinator: AmazonDevicesCoordinator,
+        serial_num: str,
+        description: AmazonDevicesMediaPlayerEntityDescription,
+    ) -> None:
+        """Initialize."""
+        self._prev_volume: int | None = None
+        super().__init__(coordinator, serial_num, description)
+
+    @property
+    def media_state(self) -> AmazonMediaState | None:
+        """Return the media state relating to device."""
+        if not self.coordinator or not self.coordinator.media_states:
+            return None
+        return self.coordinator.media_states.get(self._serial_num)
+
+    @property
+    def volume_state(self) -> AmazonVolumeState | None:
+        """Volume settings for device."""
+        if not self.coordinator or not self.coordinator.volume_states:
+            return None
+        return self.coordinator.volume_states.get(self._serial_num)
+
+    @property
+    def supported_features(self) -> MediaPlayerEntityFeature:
+        """Return dynamically supported features based on current media."""
+        features = STANDARD_SUPPORTED_FEATURES
+
+        if self.media_state is None:
+            return features
+
+        if self.media_state.pause_enabled:
+            features |= MediaPlayerEntityFeature.PLAY | MediaPlayerEntityFeature.PAUSE
+
+        if self.media_state.next_enabled:
+            features |= MediaPlayerEntityFeature.NEXT_TRACK
+
+        if self.media_state.previous_enabled:
+            features |= MediaPlayerEntityFeature.PREVIOUS_TRACK
+
+        return features
+
+    @property
+    def state(self) -> MediaPlayerState | None:
+        """Return the current state of the player."""
+        if not self.media_state:
+            return MediaPlayerState.IDLE
+        if self.media_state.player_state == "PLAYING":
+            return MediaPlayerState.PLAYING
+        if self.media_state.player_state == "PAUSED":
+            return MediaPlayerState.PAUSED
+
+        return MediaPlayerState.IDLE
+
+    @property
+    def volume_level(self) -> float | None:
+        """Return the volume level (0.0 to 1.0)."""
+        if not self.volume_state or self.volume_state.volume is None:
+            return None
+        return self.volume_state.volume / 100
+
+    @property
+    def is_volume_muted(self) -> bool | None:
+        """Return True if the volume is muted."""
+        if not self.volume_state:
+            return None
+        return self.volume_state.volume == 0
+
+    @property
+    def media_title(self) -> str | None:
+        """Track title."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_title
+
+    @property
+    def media_artist(self) -> str | None:
+        """Artist name."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_line1
+
+    @property
+    def media_album_name(self) -> str | None:
+        """Album name."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_line2
+
+    @property
+    def media_image_url(self) -> str | None:
+        """Album art URL."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_url
+
+    @property
+    def media_duration(self) -> int | None:
+        """Duration in seconds."""
+        if not self.media_state:
+            return None
+        return self.media_state.media_length
+
+    @property
+    def media_position(self) -> int | None:
+        """Current playback position in seconds."""
+        if not self.media_state:
+            return None
+        return self.media_state.media_position
+
+    @property
+    def media_position_updated_at(self) -> datetime | None:
+        """When media_position was last updated — HA uses this to interpolate the progress bar."""
+        if not self.media_state:
+            return None
+        return self.media_state.media_position_updated_at
+
+    @property
+    def media_content_type(self) -> MediaType | None:
+        """Content type — tells HA what kind of media is playing."""
+        if self.state in [MediaPlayerState.PLAYING, MediaPlayerState.PAUSED]:
+            return MediaType.MUSIC
+        return None
+
+    async def async_play_media(
+        self,
+        media_type: MediaType | str,
+        media_id: str,
+        enqueue: MediaPlayerEnqueue | None = None,
+        announce: bool | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Play a piece of media."""
+        await self.async_call_alexa_music(media_id, media_type)
+
+    @alexa_api_call
+    async def async_call_alexa_music(
+        self, search_phrase: str, provider_id: str
+    ) -> None:
+        """Call alexa music."""
+        await self.coordinator.api.call_alexa_music(
+            self.device, search_phrase, provider_id
+        )
+
+    @alexa_api_call
+    async def async_set_device_volume(self, volume: int) -> None:
+        """Set the device volume."""
+        _LOGGER.debug(
+            "Setting volume for %s to %s%%",
+            self.device.serial_number,
+            volume,
+        )
+        await self.coordinator.api.set_device_volume(self.device, volume)
+
+    async def async_set_volume_level(self, volume: float) -> None:
+        """Set the volume level (0.0 to 1.0)."""
+        device_volume = round(volume * 100)
+        await self.async_set_device_volume(device_volume)
+
+    async def async_mute_volume(self, mute: bool) -> None:
+        """Mute or un-mute the volume."""
+        # Whilst you can mute a device by asking it there appears to be
+        # no way to do this programmatically so set volume to 0
+        if not self.volume_state or self.volume_state.volume is None:
+            return
+        if mute:
+            self._prev_volume = self.volume_state.volume
+            target_volume = 0
+        else:
+            if self._prev_volume is None:
+                return
+            target_volume = self._prev_volume
+        await self.async_set_volume_level(target_volume / 100)
+
+    @alexa_api_call
+    async def _send_media_command(self, command: AmazonMediaControls) -> None:
+        _LOGGER.debug(
+            "Sending media command '%s' to %s", command, self.device.serial_number
+        )
+        await self.coordinator.api.send_media_command(self.device, command)
+
+    async def async_media_stop(self) -> None:
+        """Send stop command."""
+        await self._send_media_command(AmazonMediaControls.Stop)
+
+    async def async_media_pause(self) -> None:
+        """Send pause command."""
+        await self._send_media_command(AmazonMediaControls.Pause)
+
+    async def async_media_play(self) -> None:
+        """Send play command."""
+        await self._send_media_command(AmazonMediaControls.Play)
+
+    async def async_media_next_track(self) -> None:
+        """Send next track command."""
+        await self._send_media_command(AmazonMediaControls.Next)
+
+    async def async_media_previous_track(self) -> None:
+        """Send previous track command."""
+        await self._send_media_command(AmazonMediaControls.Previous)

homeassistant/components/anthropic/__init__.py

@@ -230,13 +230,13 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry)
 
     if entry.version == 2 and entry.minor_version == 3:
         # Remove Temperature parameter
-        CONF_TEMPERATURE = "temperature"
+        temperature_key = "temperature"
 
         for subentry in entry.subentries.values():
             data = subentry.data.copy()
-            if CONF_TEMPERATURE not in data:
+            if temperature_key not in data:
                 continue
-            data.pop(CONF_TEMPERATURE, None)
+            data.pop(temperature_key, None)
             hass.config_entries.async_update_subentry(entry, subentry, data=data)
 
         hass.config_entries.async_update_entry(entry, minor_version=4)

homeassistant/components/apcupsd/const.py

@@ -7,27 +7,3 @@ CONNECTION_TIMEOUT: int = 10
 
 # Field name of last self test retrieved from apcupsd.
 LAST_S_TEST: Final = "laststest"
-
-# Mapping of deprecated sensor keys (as reported by apcupsd,
-# lower-cased) to their deprecation
-# repair issue translation keys.
-DEPRECATED_SENSORS: Final = {
-    "apc": "apc_deprecated",
-    "end apc": "date_deprecated",
-    "date": "date_deprecated",
-    "apcmodel": "available_via_device_info",
-    "model": "available_via_device_info",
-    "firmware": "available_via_device_info",
-    "version": "available_via_device_info",
-    "upsname": "available_via_device_info",
-    "serialno": "available_via_device_info",
-}
-
-AVAILABLE_VIA_DEVICE_ATTR: Final = {
-    "apcmodel": "model",
-    "model": "model",
-    "firmware": "hw_version",
-    "version": "sw_version",
-    "upsname": "name",
-    "serialno": "serial_number",
-}

homeassistant/components/apcupsd/sensor.py

@@ -1,11 +1,10 @@
 """Support for APCUPSd sensors."""
 
 import logging
+from typing import Final
 
 import dateutil
 
-from homeassistant.components.automation import automations_with_entity
-from homeassistant.components.script import scripts_with_entity
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -24,11 +23,9 @@ from homeassistant.const import (
     UnitOfTime,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-import homeassistant.helpers.issue_registry as ir
 
-from .const import AVAILABLE_VIA_DEVICE_ATTR, DEPRECATED_SENSORS, DOMAIN, LAST_S_TEST
+from .const import LAST_S_TEST
 from .coordinator import APCUPSdConfigEntry, APCUPSdCoordinator
 from .entity import APCUPSdEntity
 
@@ -36,6 +33,20 @@ PARALLEL_UPDATES = 0
 
 _LOGGER = logging.getLogger(__name__)
 
+# List of useless sensors to ignore, since they are either provided in device
+# information, or not useful at all
+IGNORED_SENSORS: Final = {
+    "apc",
+    "end apc",
+    "date",
+    "apcmodel",
+    "model",
+    "firmware",
+    "version",
+    "upsname",
+    "serialno",
+}
+
 SENSORS: dict[str, SensorEntityDescription] = {
     "alarmdel": SensorEntityDescription(
         key="alarmdel",
@@ -49,18 +60,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
-    "apc": SensorEntityDescription(
-        key="apc",
-        translation_key="apc_status",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-    "apcmodel": SensorEntityDescription(
-        key="apcmodel",
-        translation_key="apc_model",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "badbatts": SensorEntityDescription(
         key="badbatts",
         translation_key="bad_batteries",
@@ -100,12 +99,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         state_class=SensorStateClass.TOTAL_INCREASING,
         device_class=SensorDeviceClass.DURATION,
     ),
-    "date": SensorEntityDescription(
-        key="date",
-        translation_key="date",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "dipsw": SensorEntityDescription(
         key="dipsw",
         translation_key="dip_switch_settings",
@@ -132,23 +125,11 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="wake_delay",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "end apc": SensorEntityDescription(
-        key="end apc",
-        translation_key="date_and_time",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "extbatts": SensorEntityDescription(
         key="extbatts",
         translation_key="external_batteries",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "firmware": SensorEntityDescription(
-        key="firmware",
-        translation_key="firmware_version",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "hitrans": SensorEntityDescription(
         key="hitrans",
         translation_key="transfer_high",
@@ -264,12 +245,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="min_time",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "model": SensorEntityDescription(
-        key="model",
-        translation_key="model",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "nombattv": SensorEntityDescription(
         key="nombattv",
         translation_key="battery_nominal_voltage",
@@ -358,12 +333,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "serialno": SensorEntityDescription(
-        key="serialno",
-        translation_key="serial_number",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "starttime": SensorEntityDescription(
         key="starttime",
         translation_key="startup_time",
@@ -404,18 +373,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="ups_mode",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "upsname": SensorEntityDescription(
-        key="upsname",
-        translation_key="ups_name",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-    "version": SensorEntityDescription(
-        key="version",
-        translation_key="version",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "xoffbat": SensorEntityDescription(
         key="xoffbat",
         translation_key="transfer_from_battery",
@@ -481,9 +438,10 @@ async def async_setup_entry(
     # as unknown initially.
     #
     # We also sort the resources to ensure the order of entities
-    # created is deterministic since "APCMODEL" and "MODEL"
-    # resources map to the same "Model" name.
+    # created is deterministic
     for resource in sorted(available_resources | {LAST_S_TEST}):
+        if resource in IGNORED_SENSORS:
+            continue
         if resource not in SENSORS:
             _LOGGER.warning("Invalid resource from APCUPSd: %s", resource.upper())
             continue
@@ -561,63 +519,3 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
         self._attr_native_value, inferred_unit = infer_unit(data)
         if not self.native_unit_of_measurement:
             self._attr_native_unit_of_measurement = inferred_unit
-
-    async def async_added_to_hass(self) -> None:
-        """Handle when entity is added to Home Assistant.
-
-        If this is a deprecated sensor entity, create a repair issue to guide
-        the user to disable it.
-        """
-        await super().async_added_to_hass()
-
-        if not self.enabled:
-            return
-
-        reason = DEPRECATED_SENSORS.get(self.entity_description.key)
-        if not reason:
-            return
-
-        automations = automations_with_entity(self.hass, self.entity_id)
-        scripts = scripts_with_entity(self.hass, self.entity_id)
-        if not automations and not scripts:
-            return
-
-        entity_registry = er.async_get(self.hass)
-        items = [
-            f"- [{entry.name or entry.original_name or entity_id}]"
-            f"(/config/{integration}/edit/"
-            f"{entry.unique_id or entity_id.split('.', 1)[-1]})"
-            for integration, entities in (
-                ("automation", automations),
-                ("script", scripts),
-            )
-            for entity_id in entities
-            if (entry := entity_registry.async_get(entity_id))
-        ]
-        placeholders = {
-            "entity_name": str(self.name or self.entity_id),
-            "entity_id": self.entity_id,
-            "items": "\n".join(items),
-        }
-        if via_attr := AVAILABLE_VIA_DEVICE_ATTR.get(self.entity_description.key):
-            placeholders["available_via_device_attr"] = via_attr
-        if device_entry := self.device_entry:
-            placeholders["device_id"] = device_entry.id
-
-        ir.async_create_issue(
-            self.hass,
-            DOMAIN,
-            f"{reason}_{self.entity_id}",
-            breaks_in_ha_version="2026.6.0",
-            is_fixable=False,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key=reason,
-            translation_placeholders=placeholders,
-        )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Handle when entity will be removed from Home Assistant."""
-        await super().async_will_remove_from_hass()
-
-        if issue_key := DEPRECATED_SENSORS.get(self.entity_description.key):
-            ir.async_delete_issue(self.hass, DOMAIN, f"{issue_key}_{self.entity_id}")

homeassistant/components/apcupsd/strings.json

@@ -241,19 +241,5 @@
     "cannot_connect": {
       "message": "Cannot connect to APC UPS Daemon."
     }
-  },
-  "issues": {
-    "apc_deprecated": {
-      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because it exposes internal details of the APC UPS Daemon response.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use supported APC UPS entities instead. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
-      "title": "{entity_name} sensor is deprecated"
-    },
-    "available_via_device_info": {
-      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the same value is available from the device registry via `device_attr(\"{device_id}\", \"{available_via_device_attr}\")`.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use the `device_attr` helper instead of this sensor. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
-      "title": "{entity_name} sensor is deprecated"
-    },
-    "date_deprecated": {
-      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the timestamp is already available from other APC UPS sensors via their last updated time.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to reference any entity's `last_updated` attribute instead (for example, `states.binary_sensor.apcups_online_status.last_updated`). Reload the APC UPS Daemon integration afterwards to resolve this issue.",
-      "title": "{entity_name} sensor is deprecated"
-    }
   }
 }

homeassistant/components/asuswrt/router.py

@@ -49,6 +49,20 @@ SENSORS_TYPE_COUNT = "sensors_count"
 
 _LOGGER = logging.getLogger(__name__)
 
+_ENTITY_MIGRATION_ID = {
+    "sensor_connected_device": "Devices Connected",
+    "sensor_rx_bytes": "Download",
+    "sensor_tx_bytes": "Upload",
+    "sensor_rx_rates": "Download Speed",
+    "sensor_tx_rates": "Upload Speed",
+    "sensor_load_avg1": "Load Avg (1m)",
+    "sensor_load_avg5": "Load Avg (5m)",
+    "sensor_load_avg15": "Load Avg (15m)",
+    "2.4GHz": "2.4GHz Temperature",
+    "5.0GHz": "5GHz Temperature",
+    "CPU": "CPU Temperature",
+}
+
 
 class AsusWrtSensorDataHandler:
     """Data handler for AsusWrt sensor."""
@@ -187,20 +201,6 @@ class AsusWrtRouter:
 
     def _migrate_entities_unique_id(self) -> None:
         """Migrate router entities to new unique id format."""
-        _ENTITY_MIGRATION_ID = {
-            "sensor_connected_device": "Devices Connected",
-            "sensor_rx_bytes": "Download",
-            "sensor_tx_bytes": "Upload",
-            "sensor_rx_rates": "Download Speed",
-            "sensor_tx_rates": "Upload Speed",
-            "sensor_load_avg1": "Load Avg (1m)",
-            "sensor_load_avg5": "Load Avg (5m)",
-            "sensor_load_avg15": "Load Avg (15m)",
-            "2.4GHz": "2.4GHz Temperature",
-            "5.0GHz": "5GHz Temperature",
-            "CPU": "CPU Temperature",
-        }
-
         entity_reg = er.async_get(self.hass)
         router_entries = er.async_entries_for_config_entry(
             entity_reg, self._entry.entry_id

homeassistant/components/aws_s3/__init__.py

@@ -51,7 +51,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: S3ConfigEntry) -> bool:
                 translation_key="invalid_bucket_name",
             ) from err
     except ValueError as err:
-        # pylint: disable-next=home-assistant-exception-translation-key-missing
         raise ConfigEntryError(
             translation_domain=DOMAIN,
             translation_key="invalid_endpoint_url",

homeassistant/components/aws_s3/strings.json

@@ -7,7 +7,7 @@
       "cannot_connect": "[%key:component::aws_s3::exceptions::cannot_connect::message%]",
       "invalid_bucket_name": "[%key:component::aws_s3::exceptions::invalid_bucket_name::message%]",
       "invalid_credentials": "[%key:component::aws_s3::exceptions::invalid_credentials::message%]",
-      "invalid_endpoint_url": "Invalid endpoint URL. Please make sure it's a valid AWS S3 endpoint URL."
+      "invalid_endpoint_url": "[%key:component::aws_s3::exceptions::invalid_endpoint_url::message%]"
     },
     "step": {
       "user": {
@@ -48,6 +48,9 @@
     },
     "invalid_credentials": {
       "message": "Bucket cannot be accessed using provided combination of access key ID and secret access key."
+    },
+    "invalid_endpoint_url": {
+      "message": "Invalid endpoint URL. Please make sure it's a valid AWS S3 endpoint URL."
     }
   }
 }

homeassistant/components/bluetooth/manifest.json

@@ -20,7 +20,7 @@
     "bluetooth-adapters==2.3.0",
     "bluetooth-auto-recovery==1.6.4",
     "bluetooth-data-tools==1.29.18",
-    "dbus-fast==5.0.14",
-    "habluetooth==6.7.4"
+    "dbus-fast==5.0.15",
+    "habluetooth==6.7.9"
   ]
 }

homeassistant/components/cast/config_flow.py

@@ -32,8 +32,16 @@ OPTIONS_SCHEMA = KNOWN_HOSTS_SCHEMA.extend(
         vol.Required(CONF_MORE_OPTIONS): section(
             vol.Schema(
                 {
-                    vol.Optional(CONF_UUID): str,
-                    vol.Optional(CONF_IGNORE_CEC): str,
+                    vol.Optional(CONF_UUID): SelectSelector(
+                        SelectSelectorConfig(
+                            custom_value=True, options=[], multiple=True
+                        ),
+                    ),
+                    vol.Optional(CONF_IGNORE_CEC): SelectSelector(
+                        SelectSelectorConfig(
+                            custom_value=True, options=[], multiple=True
+                        ),
+                    ),
                 }
             ),
             SectionConfig(collapsed=True),
@@ -109,13 +117,11 @@ class CastOptionsFlowHandler(OptionsFlow):
     ) -> ConfigFlowResult:
         """Manage the Google Cast options."""
         if user_input is not None:
-            ignore_cec = _string_to_list(
-                user_input[CONF_MORE_OPTIONS].get(CONF_IGNORE_CEC, "")
+            ignore_cec = _trim_items(
+                user_input[CONF_MORE_OPTIONS].get(CONF_IGNORE_CEC, [])
             )
             known_hosts = _trim_items(user_input.get(CONF_KNOWN_HOSTS, []))
-            wanted_uuid = _string_to_list(
-                user_input[CONF_MORE_OPTIONS].get(CONF_UUID, "")
-            )
+            wanted_uuid = _trim_items(user_input[CONF_MORE_OPTIONS].get(CONF_UUID, []))
             updated_config = dict(self.config_entry.data)
             updated_config[CONF_IGNORE_CEC] = ignore_cec
             updated_config[CONF_KNOWN_HOSTS] = known_hosts
@@ -132,9 +138,7 @@ class CastOptionsFlowHandler(OptionsFlow):
         for key in (CONF_UUID, CONF_IGNORE_CEC):
             if key not in self.config_entry.data:
                 continue
-            suggested[CONF_MORE_OPTIONS][key] = _list_to_string(
-                self.config_entry.data[key]
-            )
+            suggested[CONF_MORE_OPTIONS][key] = self.config_entry.data[key]
 
         return self.async_show_form(
             step_id="init",
@@ -143,16 +147,5 @@ class CastOptionsFlowHandler(OptionsFlow):
         )
 
 
-def _list_to_string(items: list[str]) -> str:
-    comma_separated_string = ""
-    if items:
-        comma_separated_string = ",".join(items)
-    return comma_separated_string
-
-
-def _string_to_list(string: str) -> list[str]:
-    return [x.strip() for x in string.split(",") if x.strip()]
-
-
 def _trim_items(items: list[str]) -> list[str]:
     return [x.strip() for x in items if x.strip()]

homeassistant/components/cert_expiry/diagnostics.py

@@ -0,0 +1,57 @@
+"""Diagnostics for the cert_expiry integration."""
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_HOST
+from homeassistant.core import HomeAssistant
+
+from .coordinator import CertExpiryConfigEntry
+
+TO_REDACT = {CONF_HOST, "name", "title", "unique_id"}
+
+
+async def async_get_config_entry_diagnostics(
+    _hass: HomeAssistant,
+    entry: CertExpiryConfigEntry,
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    entry_diagnostics = entry.as_dict()
+
+    coordinator = getattr(entry, "runtime_data", None)
+
+    coordinator_diagnostics: dict[str, Any] = {
+        "host": None,
+        "port": None,
+        "name": None,
+        "expiry_datetime": None,
+        "is_cert_valid": None,
+        "cert_error": None,
+        "last_update_success": None,
+    }
+
+    if coordinator is not None:
+        expiry = coordinator.data.isoformat() if coordinator.data else None
+        cert_error = (
+            (
+                f"{type(coordinator.cert_error).__module__}."
+                f"{type(coordinator.cert_error).__qualname__}"
+            )
+            if coordinator.cert_error
+            else None
+        )
+
+        coordinator_diagnostics = {
+            "host": coordinator.host,
+            "port": coordinator.port,
+            "name": coordinator.name,
+            "expiry_datetime": expiry,
+            "is_cert_valid": coordinator.is_cert_valid,
+            "cert_error": cert_error,
+            "last_update_success": coordinator.last_update_success,
+        }
+
+    return {
+        "entry": async_redact_data(entry_diagnostics, TO_REDACT),
+        "coordinator": async_redact_data(coordinator_diagnostics, TO_REDACT),
+    }

homeassistant/components/cert_expiry/quality_scale.yaml

@@ -0,0 +1,81 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions.
+  appropriate-polling:
+    status: done
+    comment: Certificates are checked every 12 hours via DataUpdateCoordinator.
+  brands: done
+  common-modules: done
+  config-flow-test-coverage:
+    status: done
+    comment: test_abort_on_socket_failed can be parametrized and should end in CREATE_ENTRY to test flow recovery.
+  config-flow: done
+  dependency-transparency:
+    status: exempt
+    comment: Integration has no external library dependencies.
+  docs-actions:
+    status: exempt
+    comment: Integration does not register custom actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: Integration does not subscribe to events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: todo
+  unique-config-entry: done
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: Integration does not register custom actions.
+  config-entry-unloading: done
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: todo
+  reauthentication-flow:
+    status: exempt
+    comment: Config flow only collects host/port; the integration does not authenticate.
+  test-coverage:
+    status: todo
+    comment: Consider creating a mock_config_entry fixture and use that throughout tests.
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery: todo
+  discovery-update-info: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices:
+    status: exempt
+    comment: Integration supports a single device per config entry.
+  entity-category:
+    status: todo
+    comment: Extra state attributes (is_valid, error) should be moved to separate entities in the future.
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: done
+  repair-issues: todo
+  stale-devices:
+    status: exempt
+    comment: Integration supports a single device per config entry.
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/cert_expiry/strings.json

@@ -16,6 +16,10 @@
           "host": "[%key:common::config_flow::data::host%]",
           "port": "[%key:common::config_flow::data::port%]"
         },
+        "data_description": {
+          "host": "The hostname or IP address of the server to monitor.",
+          "port": "The port to connect to on the server."
+        },
         "title": "Reconfigure the certificate to test"
       },
       "user": {
@@ -24,6 +28,10 @@
           "name": "The name of the certificate",
           "port": "[%key:common::config_flow::data::port%]"
         },
+        "data_description": {
+          "host": "The hostname or IP address of the server to monitor.",
+          "port": "The port to connect to on the server."
+        },
         "title": "Define the certificate to test"
       }
     }

homeassistant/components/config/config_entries.py

@@ -175,7 +175,6 @@ class ConfigManagerFlowIndexView(
         vol.Schema(
             {
                 vol.Required("handler"): vol.Any(str, list),
-                vol.Optional("show_advanced_options", default=False): cv.boolean,
                 vol.Optional("entry_id"): cv.string,
             },
             extra=vol.ALLOW_EXTRA,
@@ -302,7 +301,6 @@ class SubentryManagerFlowIndexView(
         vol.Schema(
             {
                 vol.Required("handler"): vol.All(vol.Coerce(tuple), (str, str)),
-                vol.Optional("show_advanced_options", default=False): cv.boolean,
             },
             extra=vol.ALLOW_EXTRA,
         )

homeassistant/components/data_grand_lyon/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/data_grand_lyon",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "quality_scale": "silver",
+  "quality_scale": "platinum",
   "requirements": ["data-grand-lyon-ha==0.7.0"]
 }

homeassistant/components/data_grand_lyon/quality_scale.yaml

@@ -49,13 +49,15 @@ rules:
     status: exempt
     comment: This is a service integration; there are no discoverable devices.
   docs-data-update: done
-  docs-examples: todo
+  docs-examples: done
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: done
+  dynamic-devices:
+    status: exempt
+    comment: This is a service integration; devices are added and removed manually by the user.
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done
@@ -66,7 +68,9 @@ rules:
   repair-issues:
     status: exempt
     comment: no known use cases for repair issues or flows, yet
-  stale-devices: done
+  stale-devices:
+    status: exempt
+    comment: This is a service integration; devices are added and removed manually by the user.
 
   # Platinum
   async-dependency: done

homeassistant/components/device_tracker/legacy.py

@@ -38,6 +38,9 @@ from homeassistant.const import (
 from homeassistant.core import Event, HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, entity_registry as er
+from homeassistant.helpers.entity_platform import (
+    async_create_platform_config_not_supported_issue,
+)
 from homeassistant.helpers.event import (
     async_track_time_interval,
     async_track_utc_time_change,
@@ -379,8 +382,8 @@ async def async_extract_config(
         if platform.type == PLATFORM_TYPE_LEGACY:
             legacy.append(platform)
         else:
-            raise ValueError(
-                f"Unable to determine type for {platform.name}: {platform.type}"
+            async_create_platform_config_not_supported_issue(
+                hass, platform.name, DOMAIN
             )
 
     return legacy

homeassistant/components/duco/strings.json

@@ -64,23 +64,23 @@
       "ventilation_state": {
         "name": "Ventilation state",
         "state": {
-          "aut1": "Automatic boost (15 min)",
-          "aut2": "Automatic boost (30 min)",
-          "aut3": "Automatic boost (45 min)",
-          "auto": "Automatic",
-          "cnt1": "Continuous low speed",
-          "cnt2": "Continuous medium speed",
-          "cnt3": "Continuous high speed",
-          "empt": "Empty house",
-          "man1": "Manual low speed (15 min)",
-          "man1x2": "Manual low speed (30 min)",
-          "man1x3": "Manual low speed (45 min)",
-          "man2": "Manual medium speed (15 min)",
-          "man2x2": "Manual medium speed (30 min)",
-          "man2x3": "Manual medium speed (45 min)",
-          "man3": "Manual high speed (15 min)",
-          "man3x2": "Manual high speed (30 min)",
-          "man3x3": "Manual high speed (45 min)"
+          "aut1": "AUT1",
+          "aut2": "AUT2",
+          "aut3": "AUT3",
+          "auto": "AUTO",
+          "cnt1": "CNT1",
+          "cnt2": "CNT2",
+          "cnt3": "CNT3",
+          "empt": "EMPT",
+          "man1": "MAN1",
+          "man1x2": "MAN1x2",
+          "man1x3": "MAN1x3",
+          "man2": "MAN2",
+          "man2x2": "MAN2x2",
+          "man2x3": "MAN2x3",
+          "man3": "MAN3",
+          "man3x2": "MAN3x2",
+          "man3x3": "MAN3x3"
         }
       }
     }

homeassistant/components/eafm/config_flow.py

@@ -41,7 +41,7 @@ class UKFloodsFlowHandler(ConfigFlow, domain=DOMAIN):
         self.stations = {}
         for station in stations:
             label = station["label"]
-            rloId = station["RLOIid"]
+            rlo_id = station["RLOIid"]
 
             # API annoyingly sometimes returns a list and some times returns a string
             # E.g. L3121 has a label of ['Scurf Dyke', 'Scurf Dyke Dyke Level']
@@ -50,11 +50,11 @@ class UKFloodsFlowHandler(ConfigFlow, domain=DOMAIN):
 
             # Similar for RLOIid
             # E.g. 0018 has an RLOIid of ['10427', '9154']
-            if isinstance(rloId, list):
-                rloId = rloId[-1]
+            if isinstance(rlo_id, list):
+                rlo_id = rlo_id[-1]
 
-            fullName = label + " - " + rloId
-            self.stations[fullName] = station["stationReference"]
+            full_name = label + " - " + rlo_id
+            self.stations[full_name] = station["stationReference"]
 
         if not self.stations:
             return self.async_abort(reason="no_stations")

homeassistant/components/elkm1/const.py

@@ -40,6 +40,7 @@ ELK_ELEMENTS = {
 EVENT_ELKM1_KEYPAD_KEY_PRESSED = "elkm1.keypad_key_pressed"
 
 
+ATTR_DURATION = "duration"
 ATTR_KEYPAD_ID = "keypad_id"
 ATTR_KEY = "key"
 ATTR_KEY_NAME = "key_name"

homeassistant/components/elkm1/icons.json

@@ -48,6 +48,9 @@
     },
     "speak_word": {
       "service": "mdi:message-minus"
+    },
+    "switch_output_turn_on_for": {
+      "service": "mdi:timer"
     }
   }
 }

homeassistant/components/elkm1/services.yaml

@@ -161,3 +161,15 @@ sensor_zone_trigger:
     entity:
       integration: elkm1
       domain: sensor
+
+switch_output_turn_on_for:
+  target:
+    entity:
+      integration: elkm1
+      domain: switch
+  fields:
+    duration:
+      example: 42
+      required: true
+      selector:
+        duration:

homeassistant/components/elkm1/strings.json

@@ -210,6 +210,16 @@
         }
       },
       "name": "Speak word"
+    },
+    "switch_output_turn_on_for": {
+      "description": "Turns on an output for a specified length of time.",
+      "fields": {
+        "duration": {
+          "description": "Length of time to turn the output on for.",
+          "name": "Duration"
+        }
+      },
+      "name": "Switch output turn on for"
     }
   }
 }

homeassistant/components/elkm1/switch.py

@@ -1,5 +1,7 @@
 """Support for control of ElkM1 outputs (relays)."""
 
+from datetime import timedelta
+from math import ceil
 from typing import Any
 
 from elkm1_lib.const import ThermostatMode, ThermostatSetting
@@ -7,15 +9,29 @@ from elkm1_lib.elements import Element
 from elkm1_lib.elk import Elk
 from elkm1_lib.outputs import Output
 from elkm1_lib.thermostats import Thermostat
+import voluptuous as vol
 
-from homeassistant.components.switch import SwitchEntity
+from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN, SwitchEntity
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv, service
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import VolDictType
 
 from . import ElkM1ConfigEntry
+from .const import ATTR_DURATION, DOMAIN
 from .entity import ElkAttachedEntity, ElkEntity, create_elk_entities
 from .models import ELKM1Data
 
+SERVICE_SWITCH_OUTPUT_TURN_ON_FOR = "switch_output_turn_on_for"
+
+ELK_OUTPUT_TURN_ON_FOR_SERVICE_SCHEMA: VolDictType = {
+    vol.Required(ATTR_DURATION): vol.All(
+        cv.time_period,
+        vol.Range(min=timedelta(seconds=1), max=timedelta(seconds=65535)),
+    ),
+}
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -32,6 +48,15 @@ async def async_setup_entry(
     )
     async_add_entities(entities)
 
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SWITCH_OUTPUT_TURN_ON_FOR,
+        entity_domain=SWITCH_DOMAIN,
+        schema=ELK_OUTPUT_TURN_ON_FOR_SERVICE_SCHEMA,
+        func="async_switch_output_turn_on_for",
+    )
+
 
 class ElkOutput(ElkAttachedEntity, SwitchEntity):
     """Elk output as switch."""
@@ -51,6 +76,10 @@ class ElkOutput(ElkAttachedEntity, SwitchEntity):
         """Turn off the output."""
         self._element.turn_off()
 
+    async def async_switch_output_turn_on_for(self, duration: timedelta) -> None:
+        """Turn on an output for specified length of time."""
+        self._element.turn_on(ceil(duration.total_seconds()))
+
 
 class ElkThermostatEMHeat(ElkEntity, SwitchEntity):
     """Elk Thermostat emergency heat as switch."""
@@ -79,3 +108,7 @@ class ElkThermostatEMHeat(ElkEntity, SwitchEntity):
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn off the output."""
         self._elk_set(ThermostatMode.EMERGENCY_HEAT)
+
+    async def async_switch_output_turn_on_for(self, duration: timedelta) -> None:
+        """Turn on an output for specified length of time: not supported for thermostat."""
+        raise HomeAssistantError("supported only on ElkM1 output switch entities")

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==45.2.2",
+    "aioesphomeapi==45.3.1",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==3.9.1"
   ],

homeassistant/components/ezviz/select.py

@@ -124,11 +124,11 @@ async def async_setup_entry(
 
     for camera in coordinator.data:
         device_category = coordinator.data[camera].get("device_category")
-        supportExt = coordinator.data[camera].get("supportExt")
+        support_ext = coordinator.data[camera].get("supportExt")
         if (
             device_category == DeviceCatagories.BATTERY_CAMERA_DEVICE_CATEGORY.value
-            and supportExt
-            and str(SupportExt.SupportBatteryManage.value) in supportExt
+            and support_ext
+            and str(SupportExt.SupportBatteryManage.value) in support_ext
         ):
             entities.append(
                 EzvizSelect(coordinator, camera, BATTERY_WORK_MODE_SELECT_TYPE)

homeassistant/components/google_air_quality/__init__.py

@@ -7,19 +7,30 @@ from google_air_quality_api.auth import Auth
 
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_REFERRER
+from .const import CONF_REFERRER, DOMAIN
 from .coordinator import (
     GoogleAirQualityConfigEntry,
     GoogleAirQualityRuntimeData,
     GoogleAirQualityUpdateCoordinator,
 )
+from .services import async_setup_services
 
 PLATFORMS: list[Platform] = [
     Platform.SENSOR,
 ]
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Google Air Quality integration."""
+    async_setup_services(hass)
+    return True
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: GoogleAirQualityConfigEntry

homeassistant/components/google_air_quality/icons.json

@@ -11,5 +11,10 @@
         "default": "mdi:molecule"
       }
     }
+  },
+  "services": {
+    "get_forecast": {
+      "service": "mdi:clock-end"
+    }
   }
 }

homeassistant/components/google_air_quality/services.py

@@ -0,0 +1,107 @@
+"""Services for the Google Air Quality integration."""
+
+from datetime import timedelta
+from typing import Final, cast
+
+from google_air_quality_api.exceptions import GoogleAirQualityApiError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import ATTR_DEVICE_ID
+from homeassistant.core import (
+    HomeAssistant,
+    ServiceCall,
+    ServiceResponse,
+    SupportsResponse,
+    callback,
+)
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.helpers import device_registry as dr, selector
+
+from .const import DOMAIN
+from .coordinator import GoogleAirQualityConfigEntry
+
+ATTR_HOURS: Final = "hours"
+
+FORECAST_HOURS_MAX: Final = 96
+
+SERVICE_GET_FORECAST: Final = "get_forecast"
+
+SERVICE_GET_FORECAST_SCHEMA: Final = vol.Schema(
+    {
+        vol.Required(ATTR_DEVICE_ID): selector.DeviceSelector({"integration": DOMAIN}),
+        vol.Required(ATTR_HOURS): vol.All(
+            vol.Coerce(int), vol.Range(min=1, max=FORECAST_HOURS_MAX)
+        ),
+    }
+)
+
+
+def _get_config_entry_and_subentry_id(
+    hass: HomeAssistant, device_id: str
+) -> tuple[GoogleAirQualityConfigEntry, str]:
+    """Get the config entry and subentry from a selected location device."""
+    device = dr.async_get(hass).async_get(device_id)
+    if device is not None:
+        for entry_id, subentry_ids in device.config_entries_subentries.items():
+            config_entry: ConfigEntry | None = hass.config_entries.async_get_entry(
+                entry_id
+            )
+            if config_entry is None or config_entry.domain != DOMAIN:
+                continue
+
+            gaq_config_entry = cast(GoogleAirQualityConfigEntry, config_entry)
+            for subentry_id in subentry_ids:
+                if (
+                    subentry_id is not None
+                    and subentry_id
+                    in gaq_config_entry.runtime_data.subentries_runtime_data
+                ):
+                    return gaq_config_entry, subentry_id
+
+    raise ServiceValidationError(
+        translation_domain=DOMAIN,
+        translation_key="device_not_found",
+    )
+
+
+async def _async_get_forecast(call: ServiceCall) -> ServiceResponse:
+    """Fetch the air quality forecast for a configured location."""
+    config_entry, subentry_id = _get_config_entry_and_subentry_id(
+        call.hass, call.data[ATTR_DEVICE_ID]
+    )
+
+    coordinator = config_entry.runtime_data.subentries_runtime_data[subentry_id]
+
+    try:
+        forecast = await config_entry.runtime_data.api.async_get_forecast(
+            coordinator.lat,
+            coordinator.long,
+            timedelta(hours=call.data[ATTR_HOURS]),
+        )
+    except GoogleAirQualityApiError as err:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="unable_to_fetch",
+        ) from err
+
+    return cast(
+        ServiceResponse,
+        {
+            "forecast_time": forecast.hourly_forecasts[0].date_time,
+            "indexes": forecast.hourly_forecasts[0].indexes,
+            "pollutants": forecast.hourly_forecasts[0].pollutants,
+        },
+    )
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_GET_FORECAST,
+        _async_get_forecast,
+        schema=SERVICE_GET_FORECAST_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
+    )

homeassistant/components/google_air_quality/services.yaml

@@ -0,0 +1,15 @@
+get_forecast:
+  fields:
+    device_id:
+      required: true
+      selector:
+        device:
+          integration: google_air_quality
+    hours:
+      required: true
+      selector:
+        number:
+          min: 1
+          max: 96
+          step: 1
+          mode: box

homeassistant/components/google_air_quality/strings.json

@@ -270,8 +270,27 @@
     }
   },
   "exceptions": {
+    "device_not_found": {
+      "message": "Location not found."
+    },
     "unable_to_fetch": {
       "message": "[%key:component::google_air_quality::common::unable_to_fetch%]"
     }
+  },
+  "services": {
+    "get_forecast": {
+      "description": "Get an air quality forecast for a configured location.",
+      "fields": {
+        "device_id": {
+          "description": "The location to fetch the forecast for.",
+          "name": "Location"
+        },
+        "hours": {
+          "description": "How many hours into the future to forecast.",
+          "name": "Hours"
+        }
+      },
+      "name": "Get forecast"
+    }
   }
 }

homeassistant/components/google_drive/api.py

@@ -117,13 +117,13 @@ class DriveClient:
         """Get storage quota of the current user."""
         res = await self._api.get_user(params={"fields": "storageQuota"})
 
-        storageQuota = res["storageQuota"]
-        limit = storageQuota.get("limit")
+        storage_quota = res["storageQuota"]
+        limit = storage_quota.get("limit")
         return StorageQuotaData(
             limit=int(limit) if limit is not None else None,
-            usage=int(storageQuota.get("usage", 0)),
-            usage_in_drive=int(storageQuota.get("usageInDrive", 0)),
-            usage_in_trash=int(storageQuota.get("usageInTrash", 0)),
+            usage=int(storage_quota.get("usage", 0)),
+            usage_in_drive=int(storage_quota.get("usageInDrive", 0)),
+            usage_in_trash=int(storage_quota.get("usageInTrash", 0)),
         )
 
     async def async_create_ha_root_folder_if_not_exists(self) -> tuple[str, str]:

homeassistant/components/google_generative_ai_conversation/const.py

@@ -19,7 +19,7 @@ DEFAULT_STT_PROMPT = "Transcribe the attached audio"
 
 CONF_RECOMMENDED = "recommended"
 CONF_CHAT_MODEL = "chat_model"
-RECOMMENDED_CHAT_MODEL = "models/gemini-2.5-flash"
+RECOMMENDED_CHAT_MODEL = "models/gemini-3.1-flash-lite"
 RECOMMENDED_STT_MODEL = RECOMMENDED_CHAT_MODEL
 RECOMMENDED_TTS_MODEL = "models/gemini-2.5-flash-preview-tts"
 RECOMMENDED_IMAGE_MODEL = "models/gemini-2.5-flash-image"

homeassistant/components/google_generative_ai_conversation/entity.py

@@ -580,17 +580,17 @@ class GoogleGenerativeAILLMBaseEntity(Entity):
 
         if tool_results:
             messages.append(_create_google_tool_response_content(tool_results))
-        generateContentConfig = self.create_generate_content_config()
-        generateContentConfig.tools = tools or None
-        generateContentConfig.system_instruction = (
+        generate_content_config = self.create_generate_content_config()
+        generate_content_config.tools = tools or None
+        generate_content_config.system_instruction = (
             prompt if supports_system_instruction else None
         )
-        generateContentConfig.automatic_function_calling = (
+        generate_content_config.automatic_function_calling = (
             AutomaticFunctionCallingConfig(disable=True, maximum_remote_calls=None)
         )
         if structure:
-            generateContentConfig.response_mime_type = "application/json"
-            generateContentConfig.response_schema = _format_schema(
+            generate_content_config.response_mime_type = "application/json"
+            generate_content_config.response_schema = _format_schema(
                 convert(
                     structure,
                     custom_serializer=(
@@ -608,7 +608,7 @@ class GoogleGenerativeAILLMBaseEntity(Entity):
                 *messages,
             ]
         chat = self._genai_client.aio.chats.create(
-            model=model_name, history=messages, config=generateContentConfig
+            model=model_name, history=messages, config=generate_content_config
         )
         user_message = chat_log.content[-1]
         assert isinstance(user_message, conversation.UserContent)

homeassistant/components/habitica/services.py

@@ -313,7 +313,7 @@ async def _manage_quests(call: ServiceCall) -> ServiceResponse:
     )
     coordinator = entry.runtime_data
 
-    FUNC_MAP = {
+    func_map = {
         SERVICE_ABORT_QUEST: coordinator.habitica.abort_quest,
         SERVICE_ACCEPT_QUEST: coordinator.habitica.accept_quest,
         SERVICE_CANCEL_QUEST: coordinator.habitica.cancel_quest,
@@ -322,7 +322,7 @@ async def _manage_quests(call: ServiceCall) -> ServiceResponse:
         SERVICE_START_QUEST: coordinator.habitica.start_quest,
     }
 
-    func = FUNC_MAP[call.service]
+    func = func_map[call.service]
 
     try:
         response = await func()

homeassistant/components/hassio/const.py

@@ -131,12 +131,8 @@ ATTR_AUTO_UPDATE = "auto_update"
 ATTR_VERSION = "version"
 ATTR_VERSION_LATEST = "version_latest"
 ATTR_CPU_PERCENT = "cpu_percent"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_LOCATION = "location"
 ATTR_MEMORY_PERCENT = "memory_percent"
 ATTR_SLUG = "slug"
-# pylint: disable-next=home-assistant-duplicate-const
-ATTR_STATE = "state"
 ATTR_STARTED = "started"
 ATTR_URL = "url"
 ATTR_REPOSITORY = "repository"
@@ -177,19 +173,6 @@ CORE_CONTAINER = "homeassistant"
 SUPERVISOR_CONTAINER = "hassio_supervisor"
 
 CONTAINER_STATS = "stats"
-CONTAINER_INFO = "info"
-
-# This is a mapping of which endpoint the key in the addon data
-# is obtained from so we know which endpoint to update when the
-# coordinator polls for updates.
-KEY_TO_UPDATE_TYPES: dict[str, set[str]] = {
-    ATTR_VERSION_LATEST: {CONTAINER_INFO},
-    ATTR_MEMORY_PERCENT: {CONTAINER_STATS},
-    ATTR_CPU_PERCENT: {CONTAINER_STATS},
-    ATTR_VERSION: {CONTAINER_INFO},
-    ATTR_STATE: {CONTAINER_INFO},
-}
-
 REQUEST_REFRESH_DELAY = 10
 
 HELP_URLS = {

homeassistant/components/hassio/services.py

@@ -15,7 +15,7 @@ from aiohasupervisor.models import (
 )
 import voluptuous as vol
 
-from homeassistant.const import ATTR_DEVICE_ID, ATTR_NAME
+from homeassistant.const import ATTR_DEVICE_ID, ATTR_LOCATION, ATTR_NAME
 from homeassistant.core import (
     HomeAssistant,
     ServiceCall,
@@ -43,7 +43,6 @@ from .const import (
     ATTR_HOMEASSISTANT,
     ATTR_HOMEASSISTANT_EXCLUDE_DATABASE,
     ATTR_INPUT,
-    ATTR_LOCATION,
     ATTR_PASSWORD,
     ATTR_SLUG,
     DOMAIN,

homeassistant/components/homee/cover.py

@@ -30,6 +30,11 @@ OPEN_CLOSE_ATTRIBUTES = [
     AttributeType.UP_DOWN,
 ]
 POSITION_ATTRIBUTES = [AttributeType.POSITION, AttributeType.SHUTTER_SLAT_POSITION]
+COVER_DEVICE_PROFILES = {
+    NodeProfile.GARAGE_DOOR_OPERATOR: CoverDeviceClass.GARAGE,
+    NodeProfile.ENTRANCE_GATE_OPERATOR: CoverDeviceClass.GATE,
+    NodeProfile.SHUTTER_POSITION_SWITCH: CoverDeviceClass.SHUTTER,
+}
 
 
 def get_open_close_attribute(node: HomeeNode) -> HomeeAttribute | None:
@@ -69,12 +74,6 @@ def get_cover_features(
 
 def get_device_class(node: HomeeNode) -> CoverDeviceClass | None:
     """Determine the device class a homee node based on the node profile."""
-    COVER_DEVICE_PROFILES = {
-        NodeProfile.GARAGE_DOOR_OPERATOR: CoverDeviceClass.GARAGE,
-        NodeProfile.ENTRANCE_GATE_OPERATOR: CoverDeviceClass.GATE,
-        NodeProfile.SHUTTER_POSITION_SWITCH: CoverDeviceClass.SHUTTER,
-    }
-
     return COVER_DEVICE_PROFILES.get(node.profile)
 
 

homeassistant/components/incomfort/binary_sensor.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, override
 
 from incomfortclient import Heater as InComfortHeater
 
@@ -97,11 +97,13 @@ class IncomfortBinarySensor(IncomfortBoilerEntity, BinarySensorEntity):
         self._attr_unique_id = f"{heater.serial_no}_{description.key}"
 
     @property
+    @override
     def is_on(self) -> bool:
         """Return the status of the sensor."""
         return bool(self._heater.status[self.entity_description.value_key])
 
     @property
+    @override
     def extra_state_attributes(self) -> dict[str, Any] | None:
         """Return the device state attributes."""
         if (attributes_fn := self.entity_description.extra_state_attributes_fn) is None:

homeassistant/components/incomfort/climate.py

@@ -1,6 +1,6 @@
 """Support for an Intergas boiler via an InComfort/InTouch Lan2RF gateway."""
 
-from typing import Any
+from typing import Any, override
 
 from incomfortclient import Heater as InComfortHeater, Room as InComfortRoom
 
@@ -76,16 +76,19 @@ class InComfortClimate(IncomfortEntity, ClimateEntity):
             )
 
     @property
+    @override
     def extra_state_attributes(self) -> dict[str, Any]:
         """Return the device state attributes."""
         return {"status": self._room.status}
 
     @property
+    @override
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
         return self._room.room_temp
 
     @property
+    @override
     def hvac_action(self) -> HVACAction | None:
         """Return the actual current HVAC action."""
         if self._heater.is_burning and self._heater.is_pumping:
@@ -93,6 +96,7 @@ class InComfortClimate(IncomfortEntity, ClimateEntity):
         return HVACAction.IDLE
 
     @property
+    @override
     def target_temperature(self) -> float | None:
         """Return the (override)temperature we try to reach.
 
@@ -106,11 +110,13 @@ class InComfortClimate(IncomfortEntity, ClimateEntity):
             return self._room.setpoint
         return self._room.override or self._room.setpoint
 
+    @override
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set a new target temperature for this zone."""
         temperature: float = kwargs[ATTR_TEMPERATURE]
         await self._room.set_override(temperature)
         await self.coordinator.async_refresh()
 
+    @override
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set new target hvac mode."""

homeassistant/components/incomfort/config_flow.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Mapping
 import logging
-from typing import Any
+from typing import Any, override
 
 from incomfortclient import InvalidGateway, InvalidHeaterList
 import voluptuous as vol
@@ -100,6 +100,7 @@ class InComfortConfigFlow(ConfigFlow, domain=DOMAIN):
 
     _discovered_host: str
 
+    @override
     @staticmethod
     @callback
     def async_get_options_flow(
@@ -108,6 +109,7 @@ class InComfortConfigFlow(ConfigFlow, domain=DOMAIN):
         """Get the options flow for this handler."""
         return InComfortOptionsFlowHandler()
 
+    @override
     async def async_step_dhcp(
         self, discovery_info: DhcpServiceInfo
     ) -> ConfigFlowResult:
@@ -169,6 +171,7 @@ class InComfortConfigFlow(ConfigFlow, domain=DOMAIN):
             description_placeholders={CONF_HOST: self._discovered_host},
         )
 
+    @override
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/incomfort/coordinator.py

@@ -3,7 +3,7 @@
 from dataclasses import dataclass, field
 from datetime import timedelta
 import logging
-from typing import Any
+from typing import Any, override
 
 from aiohttp import ClientResponseError
 from incomfortclient import (
@@ -74,6 +74,7 @@ class InComfortDataCoordinator(DataUpdateCoordinator[InComfortData]):
         )
         self.incomfort_data = incomfort_data
 
+    @override
     async def _async_update_data(self) -> InComfortData:
         """Fetch data from API endpoint."""
         try:

homeassistant/components/incomfort/sensor.py

@@ -1,7 +1,7 @@
 """Support for an Intergas heater via an InComfort/InTouch Lan2RF gateway."""
 
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, override
 
 from incomfortclient import Heater as InComfortHeater
 
@@ -104,11 +104,13 @@ class IncomfortSensor(IncomfortBoilerEntity, SensorEntity):
         self._attr_unique_id = f"{heater.serial_no}_{description.key}"
 
     @property
+    @override
     def native_value(self) -> StateType:
         """Return the state of the sensor."""
         return self._heater.status[self.entity_description.value_key]  # type: ignore [no-any-return]
 
     @property
+    @override
     def extra_state_attributes(self) -> dict[str, Any] | None:
         """Return the device state attributes."""
         if (extra_key := self.entity_description.extra_key) is None:

homeassistant/components/incomfort/water_heater.py

@@ -1,7 +1,7 @@
 """Support for an Intergas boiler via an InComfort/Intouch Lan2RF gateway."""
 
 import logging
-from typing import Any
+from typing import Any, override
 
 from incomfortclient import Heater as InComfortHeater
 
@@ -49,11 +49,13 @@ class IncomfortWaterHeater(IncomfortBoilerEntity, WaterHeaterEntity):
         self._attr_unique_id = heater.serial_no
 
     @property
+    @override
     def extra_state_attributes(self) -> dict[str, Any]:
         """Return the device state attributes."""
         return {k: v for k, v in self._heater.status.items() if k in HEATER_ATTRS}
 
     @property
+    @override
     def current_temperature(self) -> float | None:
         """Return the current temperature."""
         if self._heater.is_tapping:
@@ -67,6 +69,7 @@ class IncomfortWaterHeater(IncomfortBoilerEntity, WaterHeaterEntity):
         return max(self._heater.heater_temp, self._heater.tap_temp)
 
     @property
+    @override
     def current_operation(self) -> str | None:
         """Return the current operation mode."""
         return self._heater.display_text

homeassistant/components/indevolt/const.py

@@ -32,6 +32,7 @@ SENSOR_KEYS: Final[dict[int, list[str]]] = {
         IndevoltSystem.OFF_GRID_OUTPUT_ENERGY,
         IndevoltSystem.BYPASS_POWER,
         IndevoltSystem.BYPASS_INPUT_ENERGY,
+        IndevoltBattery.RATED_CAPACITY,
         IndevoltBattery.DAILY_CHARGING_ENERGY,
         IndevoltBattery.DAILY_DISCHARGING_ENERGY,
         IndevoltBattery.TOTAL_CHARGING_ENERGY,
@@ -78,7 +79,7 @@ SENSOR_KEYS: Final[dict[int, list[str]]] = {
         IndevoltSolar.DC_INPUT_POWER_2,
         IndevoltSolar.DC_INPUT_POWER_3,
         IndevoltSolar.DC_INPUT_POWER_4,
-        IndevoltBattery.RATED_CAPACITY_GEN2,
+        IndevoltBattery.RATED_CAPACITY,
         IndevoltSystem.BYPASS_POWER,
         IndevoltSystem.TOTAL_OUTPUT_ENERGY,
         IndevoltSystem.OFF_GRID_OUTPUT_ENERGY,
@@ -134,6 +135,12 @@ SENSOR_KEYS: Final[dict[int, list[str]]] = {
         IndevoltBattery.PACK_3_CURRENT,
         IndevoltBattery.PACK_4_CURRENT,
         IndevoltBattery.PACK_5_CURRENT,
+        IndevoltBattery.MAIN_CYCLES,
+        IndevoltBattery.PACK_1_CYCLES,
+        IndevoltBattery.PACK_2_CYCLES,
+        IndevoltBattery.PACK_3_CYCLES,
+        IndevoltBattery.PACK_4_CYCLES,
+        IndevoltBattery.PACK_5_CYCLES,
         IndevoltConfig.READ_BYPASS,
         IndevoltConfig.READ_GRID_CHARGING,
         IndevoltConfig.READ_LIGHT,

homeassistant/components/indevolt/coordinator.py

@@ -1,6 +1,7 @@
 """Home Assistant integration for Indevolt device."""
 
 from datetime import timedelta
+import itertools
 import logging
 from typing import Any, Final
 
@@ -29,6 +30,7 @@ from .const import (
 )
 
 _LOGGER = logging.getLogger(__name__)
+SCAN_BATCH_SIZE: Final = 50
 SCAN_INTERVAL: Final = 30
 
 type IndevoltConfigEntry = ConfigEntry[IndevoltCoordinator]
@@ -86,10 +88,13 @@ class IndevoltCoordinator(DataUpdateCoordinator[dict[str, Any]]):
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Fetch raw JSON data from the device."""
+        data: dict[str, Any] = {}
         sensor_keys = SENSOR_KEYS[self.generation]
 
         try:
-            return await self.api.fetch_data(sensor_keys)
+            for chunk in itertools.batched(sensor_keys, SCAN_BATCH_SIZE, strict=False):
+                data.update(await self.api.fetch_data(list(chunk)))
+
         except (ClientError, OSError) as err:
             raise UpdateFailed(
                 translation_domain=DOMAIN,
@@ -97,6 +102,9 @@ class IndevoltCoordinator(DataUpdateCoordinator[dict[str, Any]]):
                 translation_placeholders={"error": str(err)},
             ) from err
 
+        else:
+            return data
+
     async def async_push_data(self, sensor_key: str, value: Any) -> bool:
         """Push/write data values to given key on the device."""
         return await self.api.set_data(sensor_key, value)

homeassistant/components/indevolt/sensor.py

@@ -73,12 +73,10 @@ SENSORS: Final = (
         device_class=SensorDeviceClass.ENUM,
     ),
     IndevoltSensorEntityDescription(
-        key=IndevoltBattery.RATED_CAPACITY_GEN2,
-        generation=(2,),
+        key=IndevoltBattery.RATED_CAPACITY,
         translation_key="rated_capacity",
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
-        state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     IndevoltSensorEntityDescription(
         key=IndevoltConfig.READ_DISCHARGE_LIMIT,
@@ -132,7 +130,7 @@ SENSORS: Final = (
     IndevoltSensorEntityDescription(
         key=IndevoltBattery.GEN_2_CYCLE_COUNT,
         generation=(2,),
-        translation_key="cycle_count",
+        translation_key="equivalent_full_cycles",
         state_class=SensorStateClass.TOTAL_INCREASING,
         entity_category=EntityCategory.DIAGNOSTIC,
         entity_registry_enabled_default=False,
@@ -794,9 +792,58 @@ SENSORS: Final = (
         entity_category=EntityCategory.DIAGNOSTIC,
         entity_registry_enabled_default=False,
     ),
+    # Battery Pack Cycles
+    IndevoltSensorEntityDescription(
+        key=IndevoltBattery.MAIN_CYCLES,
+        generation=(2,),
+        translation_key="main_cycles",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    IndevoltSensorEntityDescription(
+        key=IndevoltBattery.PACK_1_CYCLES,
+        generation=(2,),
+        translation_key="battery_pack_1_cycles",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    IndevoltSensorEntityDescription(
+        key=IndevoltBattery.PACK_2_CYCLES,
+        generation=(2,),
+        translation_key="battery_pack_2_cycles",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    IndevoltSensorEntityDescription(
+        key=IndevoltBattery.PACK_3_CYCLES,
+        generation=(2,),
+        translation_key="battery_pack_3_cycles",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    IndevoltSensorEntityDescription(
+        key=IndevoltBattery.PACK_4_CYCLES,
+        generation=(2,),
+        translation_key="battery_pack_4_cycles",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    IndevoltSensorEntityDescription(
+        key=IndevoltBattery.PACK_5_CYCLES,
+        generation=(2,),
+        translation_key="battery_pack_5_cycles",
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
 )
 
-# Sensors per battery pack (SN, SOC, Temperature, MOS Temperature, Voltage, Current)
+# Sensors per battery pack (SN, SOC, Temperature, MOS Temperature, Voltage, Current, Cycles)
 BATTERY_PACK_SENSOR_KEYS = [
     (
         IndevoltBattery.PACK_1_SERIAL_NUMBER,
@@ -805,6 +852,7 @@ BATTERY_PACK_SENSOR_KEYS = [
         IndevoltBattery.PACK_1_MOS_TEMPERATURE,
         IndevoltBattery.PACK_1_VOLTAGE,
         IndevoltBattery.PACK_1_CURRENT,
+        IndevoltBattery.PACK_1_CYCLES,
     ),
     (
         IndevoltBattery.PACK_2_SERIAL_NUMBER,
@@ -813,6 +861,7 @@ BATTERY_PACK_SENSOR_KEYS = [
         IndevoltBattery.PACK_2_MOS_TEMPERATURE,
         IndevoltBattery.PACK_2_VOLTAGE,
         IndevoltBattery.PACK_2_CURRENT,
+        IndevoltBattery.PACK_2_CYCLES,
     ),
     (
         IndevoltBattery.PACK_3_SERIAL_NUMBER,
@@ -821,6 +870,7 @@ BATTERY_PACK_SENSOR_KEYS = [
         IndevoltBattery.PACK_3_MOS_TEMPERATURE,
         IndevoltBattery.PACK_3_VOLTAGE,
         IndevoltBattery.PACK_3_CURRENT,
+        IndevoltBattery.PACK_3_CYCLES,
     ),
     (
         IndevoltBattery.PACK_4_SERIAL_NUMBER,
@@ -829,6 +879,7 @@ BATTERY_PACK_SENSOR_KEYS = [
         IndevoltBattery.PACK_4_MOS_TEMPERATURE,
         IndevoltBattery.PACK_4_VOLTAGE,
         IndevoltBattery.PACK_4_CURRENT,
+        IndevoltBattery.PACK_4_CYCLES,
     ),
     (
         IndevoltBattery.PACK_5_SERIAL_NUMBER,
@@ -837,6 +888,7 @@ BATTERY_PACK_SENSOR_KEYS = [
         IndevoltBattery.PACK_5_MOS_TEMPERATURE,
         IndevoltBattery.PACK_5_VOLTAGE,
         IndevoltBattery.PACK_5_CURRENT,
+        IndevoltBattery.PACK_5_CYCLES,
     ),
 ]
 

homeassistant/components/indevolt/strings.json

@@ -118,6 +118,9 @@
       "battery_pack_1_current": {
         "name": "Battery pack 1 current"
       },
+      "battery_pack_1_cycles": {
+        "name": "Battery pack 1 cycle count"
+      },
       "battery_pack_1_mos_temperature": {
         "name": "Battery pack 1 MOS temperature"
       },
@@ -136,6 +139,9 @@
       "battery_pack_2_current": {
         "name": "Battery pack 2 current"
       },
+      "battery_pack_2_cycles": {
+        "name": "Battery pack 2 cycle count"
+      },
       "battery_pack_2_mos_temperature": {
         "name": "Battery pack 2 MOS temperature"
       },
@@ -154,6 +160,9 @@
       "battery_pack_3_current": {
         "name": "Battery pack 3 current"
       },
+      "battery_pack_3_cycles": {
+        "name": "Battery pack 3 cycle count"
+      },
       "battery_pack_3_mos_temperature": {
         "name": "Battery pack 3 MOS temperature"
       },
@@ -172,6 +181,9 @@
       "battery_pack_4_current": {
         "name": "Battery pack 4 current"
       },
+      "battery_pack_4_cycles": {
+        "name": "Battery pack 4 cycle count"
+      },
       "battery_pack_4_mos_temperature": {
         "name": "Battery pack 4 MOS temperature"
       },
@@ -190,6 +202,9 @@
       "battery_pack_5_current": {
         "name": "Battery pack 5 current"
       },
+      "battery_pack_5_cycles": {
+        "name": "Battery pack 5 cycle count"
+      },
       "battery_pack_5_mos_temperature": {
         "name": "Battery pack 5 MOS temperature"
       },
@@ -226,9 +241,6 @@
       "cumulative_production": {
         "name": "Cumulative production"
       },
-      "cycle_count": {
-        "name": "Cycle count"
-      },
       "daily_production": {
         "name": "Daily production"
       },
@@ -283,6 +295,9 @@
           "self_consumed_prioritized": "Self-consumed prioritized"
         }
       },
+      "equivalent_full_cycles": {
+        "name": "Equivalent full cycles"
+      },
       "grid_frequency": {
         "name": "Grid frequency"
       },
@@ -295,6 +310,9 @@
       "main_current": {
         "name": "Main current"
       },
+      "main_cycles": {
+        "name": "Main cycle count"
+      },
       "main_mos_temperature": {
         "name": "Main MOS temperature"
       },

homeassistant/components/infrared/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/infrared",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["infrared-protocols==5.6.0"]
+  "requirements": ["infrared-protocols==5.6.1"]
 }

homeassistant/components/ios/notify.py

@@ -30,8 +30,8 @@ def log_rate_limits(
 ) -> None:
     """Output rate limit log line at given level."""
     rate_limits = resp["rateLimits"]
-    resetsAt = dt_util.parse_datetime(rate_limits["resetsAt"])
-    resetsAtTime = resetsAt - dt_util.utcnow() if resetsAt is not None else "---"
+    resets_at = dt_util.parse_datetime(rate_limits["resetsAt"])
+    resets_at_time = resets_at - dt_util.utcnow() if resets_at is not None else "---"
     rate_limit_msg = (
         "iOS push notification rate limits for %s: "
         "%d sent, %d allowed, %d errors, "
@@ -44,7 +44,7 @@ def log_rate_limits(
         rate_limits["successful"],
         rate_limits["maximum"],
         rate_limits["errors"],
-        str(resetsAtTime).split(".", maxsplit=1)[0],
+        str(resets_at_time).split(".", maxsplit=1)[0],
     )
 
 

homeassistant/components/israel_rail/coordinator.py

@@ -79,6 +79,17 @@ class IsraelRailDataUpdateCoordinator(DataUpdateCoordinator[list[DataConnection]
                 "Unable to connect and retrieve data from israelrail api",
             ) from e
 
+        offset = 0
+        now = dt_util.now()
+        while offset < len(train_routes):
+            route = train_routes[offset]
+            if route is None:
+                break
+            route_departure = departure_time(route)
+            if route_departure is None or route_departure >= now:
+                break
+            offset += 1
+
         return [
             DataConnection(
                 departure=departure_time(train_routes[i]),
@@ -89,6 +100,6 @@ class IsraelRailDataUpdateCoordinator(DataUpdateCoordinator[list[DataConnection]
                 start=station_name_to_id(train_routes[i].trains[0].src),
                 destination=station_name_to_id(train_routes[i].trains[-1].dst),
             )
-            for i in range(DEPARTURES_COUNT)
+            for i in range(offset, offset + DEPARTURES_COUNT)
             if len(train_routes) > i and train_routes[i] is not None
         ]

homeassistant/components/israel_rail/sensor.py

@@ -52,30 +52,46 @@ DEPARTURE_SENSORS: tuple[IsraelRailSensorEntityDescription, ...] = (
 )
 
 SENSORS: tuple[IsraelRailSensorEntityDescription, ...] = (
-    IsraelRailSensorEntityDescription(
-        key="platform",
-        translation_key="platform",
-        value_fn=lambda data_connection: data_connection.platform,
-    ),
-    IsraelRailSensorEntityDescription(
-        key="trains",
-        translation_key="trains",
-        value_fn=lambda data_connection: data_connection.trains,
-    ),
-    IsraelRailSensorEntityDescription(
-        key="train_number",
-        translation_key="train_number",
-        value_fn=lambda data_connection: data_connection.train_number,
-    ),
-    IsraelRailSensorEntityDescription(
-        key="departure_delay",
-        translation_key="departure_delay",
-        device_class=SensorDeviceClass.DURATION,
-        native_unit_of_measurement=UnitOfTime.MINUTES,
-        state_class=SensorStateClass.MEASUREMENT,
-        suggested_display_precision=0,
-        value_fn=lambda data_connection: data_connection.departure_delay,
-    ),
+    *[
+        IsraelRailSensorEntityDescription(
+            key=f"platform{i or ''}",
+            translation_key=f"platform{i or ''}",
+            value_fn=lambda data_connection: data_connection.platform,
+            index=i,
+        )
+        for i in range(DEPARTURES_COUNT)
+    ],
+    *[
+        IsraelRailSensorEntityDescription(
+            key=f"trains{i or ''}",
+            translation_key=f"trains{i or ''}",
+            value_fn=lambda data_connection: data_connection.trains,
+            index=i,
+        )
+        for i in range(DEPARTURES_COUNT)
+    ],
+    *[
+        IsraelRailSensorEntityDescription(
+            key=f"train_number{i or ''}",
+            translation_key=f"train_number{i or ''}",
+            value_fn=lambda data_connection: data_connection.train_number,
+            index=i,
+        )
+        for i in range(DEPARTURES_COUNT)
+    ],
+    *[
+        IsraelRailSensorEntityDescription(
+            key=f"departure_delay{i or ''}",
+            translation_key=f"departure_delay{i or ''}",
+            device_class=SensorDeviceClass.DURATION,
+            native_unit_of_measurement=UnitOfTime.MINUTES,
+            state_class=SensorStateClass.MEASUREMENT,
+            suggested_display_precision=0,
+            value_fn=lambda data_connection: data_connection.departure_delay,
+            index=i,
+        )
+        for i in range(DEPARTURES_COUNT)
+    ],
 )
 
 

homeassistant/components/israel_rail/strings.json

@@ -31,14 +31,38 @@
       "departure_delay": {
         "name": "Departure delay"
       },
+      "departure_delay1": {
+        "name": "Departure delay +1"
+      },
+      "departure_delay2": {
+        "name": "Departure delay +2"
+      },
       "platform": {
         "name": "Platform"
       },
+      "platform1": {
+        "name": "Platform +1"
+      },
+      "platform2": {
+        "name": "Platform +2"
+      },
       "train_number": {
         "name": "Train number"
       },
+      "train_number1": {
+        "name": "Train number +1"
+      },
+      "train_number2": {
+        "name": "Train number +2"
+      },
       "trains": {
         "name": "Trains"
+      },
+      "trains1": {
+        "name": "Trains +1"
+      },
+      "trains2": {
+        "name": "Trains +2"
       }
     }
   }

homeassistant/components/jewish_calendar/sensor.py

@@ -88,6 +88,9 @@ INFO_SENSORS: tuple[JewishCalendarSensorDescription, ...] = (
                 dict.fromkeys(_holiday.type.name for _holiday in info.holidays)
             ),
         },
+        next_update_fn=lambda zmanim: (
+            zmanim.candle_lighting or zmanim.havdalah or zmanim.shkia.local
+        ),
     ),
     JewishCalendarSensorDescription(
         key="omer_count",

homeassistant/components/kitchen_sink/__init__.py

@@ -8,8 +8,6 @@ import datetime
 from functools import partial
 from random import random
 
-import voluptuous as vol
-
 from homeassistant.components.labs import (
     EventLabsUpdatedData,
     async_is_preview_feature_enabled,
@@ -34,7 +32,7 @@ from homeassistant.const import (
     UnitOfTemperature,
     UnitOfVolume,
 )
-from homeassistant.core import HomeAssistant, ServiceCall, ServiceResponse, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device_registry import DeviceEntry
 from homeassistant.helpers.issue_registry import (
@@ -51,9 +49,11 @@ from homeassistant.util.unit_conversion import (
 )
 
 from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
+from .services import async_setup_services
 
 COMPONENTS_WITH_DEMO_PLATFORM = [
     Platform.BUTTON,
+    Platform.DEVICE_TRACKER,
     Platform.FAN,
     Platform.EVENT,
     Platform.IMAGE,
@@ -69,15 +69,6 @@ COMPONENTS_WITH_DEMO_PLATFORM = [
 
 CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
-SCHEMA_SERVICE_TEST_SERVICE_1 = vol.Schema(
-    {
-        vol.Required("field_1"): vol.Coerce(int),
-        vol.Required("field_2"): vol.In(["off", "auto", "cool"]),
-        vol.Optional("field_3"): vol.Coerce(int),
-        vol.Optional("field_4"): vol.In(["forwards", "reverse"]),
-    }
-)
-
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the demo environment."""
@@ -87,24 +78,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         )
     )
 
-    @callback
-    def service_handler(call: ServiceCall | None = None) -> ServiceResponse:
-        """Do nothing."""
-        return None
-
-    hass.services.async_register(
-        DOMAIN,
-        "test_service_1",
-        service_handler,
-        SCHEMA_SERVICE_TEST_SERVICE_1,
-        description_placeholders={
-            "meep_1": "foo",
-            "meep_2": "bar",
-            "meep_3": "beer",
-            "meep_4": "milk",
-            "meep_5": "https://example.com",
-        },
-    )
+    async_setup_services(hass)
 
     return True
 

homeassistant/components/kitchen_sink/device_tracker.py

@@ -0,0 +1,97 @@
+"""Demo platform that has a couple of fake device trackers."""
+
+from homeassistant.components.device_tracker import (
+    BaseScannerEntity,
+    SourceType,
+    TrackerEntity,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Everything but the Kitchen Sink config entry."""
+    async_add_entities(
+        [
+            DemoTracker(
+                unique_id="kitchen_sink_tracker_001",
+                name="Demo tracker",
+                latitude=hass.config.latitude,
+                longitude=hass.config.longitude,
+                accuracy=10,
+            ),
+            DemoScanner(
+                unique_id="kitchen_sink_scanner_001",
+                name="Demo scanner",
+                is_connected=True,
+            ),
+        ]
+    )
+
+
+class DemoTracker(TrackerEntity):
+    """Representation of a demo tracker."""
+
+    _attr_should_poll = False
+    _attr_source_type = SourceType.GPS
+
+    def __init__(
+        self,
+        *,
+        unique_id: str,
+        name: str,
+        latitude: float | None,
+        longitude: float | None,
+        accuracy: float,
+    ) -> None:
+        """Initialize the tracker."""
+        self._attr_unique_id = unique_id
+        self._attr_name = name
+        self._attr_latitude = latitude
+        self._attr_longitude = longitude
+        self._attr_location_accuracy = accuracy
+
+    @callback
+    def async_set_tracker_location(
+        self, latitude: float, longitude: float, accuracy: float
+    ) -> None:
+        """Update the tracker location."""
+        self._attr_latitude = latitude
+        self._attr_longitude = longitude
+        self._attr_location_accuracy = accuracy
+        self.async_write_ha_state()
+
+
+class DemoScanner(BaseScannerEntity):
+    """Representation of a demo scanner."""
+
+    _attr_should_poll = False
+    _attr_source_type = SourceType.ROUTER
+
+    def __init__(
+        self,
+        *,
+        unique_id: str,
+        name: str,
+        is_connected: bool,
+    ) -> None:
+        """Initialize the scanner."""
+        self._attr_unique_id = unique_id
+        self._attr_name = name
+        self._is_connected = is_connected
+
+    @property
+    def is_connected(self) -> bool:
+        """Return true if the device is connected."""
+        return self._is_connected
+
+    @callback
+    def async_set_scanner_connected(self, connected: bool) -> None:
+        """Update the scanner connected state."""
+        self._is_connected = connected
+        self.async_write_ha_state()

homeassistant/components/kitchen_sink/icons.json

@@ -9,6 +9,12 @@
     }
   },
   "services": {
+    "set_scanner_connected": {
+      "service": "mdi:lan-connect"
+    },
+    "set_tracker_location": {
+      "service": "mdi:map-marker"
+    },
     "test_service_1": {
       "sections": {
         "additional_fields": "mdi:test-tube"

homeassistant/components/kitchen_sink/services.py

@@ -0,0 +1,72 @@
+"""Services for the Everything but the Kitchen Sink integration."""
+
+import voluptuous as vol
+
+from homeassistant.components.device_tracker import DOMAIN as DEVICE_TRACKER_DOMAIN
+from homeassistant.const import ATTR_LATITUDE, ATTR_LONGITUDE
+from homeassistant.core import HomeAssistant, ServiceCall, ServiceResponse, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+SCHEMA_SERVICE_TEST_SERVICE_1 = vol.Schema(
+    {
+        vol.Required("field_1"): vol.Coerce(int),
+        vol.Required("field_2"): vol.In(["off", "auto", "cool"]),
+        vol.Optional("field_3"): vol.Coerce(int),
+        vol.Optional("field_4"): vol.In(["forward", "reverse"]),
+    }
+)
+
+SERVICE_TEST_SERVICE_1 = "test_service_1"
+SERVICE_SET_TRACKER_LOCATION = "set_tracker_location"
+SERVICE_SET_SCANNER_CONNECTED = "set_scanner_connected"
+
+ATTR_ACCURACY = "accuracy"
+ATTR_CONNECTED = "connected"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Register services for the Kitchen Sink integration."""
+
+    @callback
+    def service_handler(call: ServiceCall) -> ServiceResponse:
+        """Do nothing."""
+        return None
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_TEST_SERVICE_1,
+        service_handler,
+        SCHEMA_SERVICE_TEST_SERVICE_1,
+        description_placeholders={
+            "meep_1": "foo",
+            "meep_2": "bar",
+            "meep_3": "beer",
+            "meep_4": "milk",
+            "meep_5": "https://example.com",
+        },
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_TRACKER_LOCATION,
+        entity_domain=DEVICE_TRACKER_DOMAIN,
+        schema={
+            vol.Required(ATTR_LATITUDE): cv.latitude,
+            vol.Required(ATTR_LONGITUDE): cv.longitude,
+            vol.Required(ATTR_ACCURACY): vol.All(vol.Coerce(float), vol.Range(min=0)),
+        },
+        func="async_set_tracker_location",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_SCANNER_CONNECTED,
+        entity_domain=DEVICE_TRACKER_DOMAIN,
+        schema={vol.Required(ATTR_CONNECTED): cv.boolean},
+        func="async_set_scanner_connected",
+    )

homeassistant/components/kitchen_sink/services.yaml

@@ -30,3 +30,44 @@ test_service_1:
               options:
                 - "forward"
                 - "reverse"
+set_tracker_location:
+  target:
+    entity:
+      integration: kitchen_sink
+      domain: device_tracker
+  fields:
+    latitude:
+      required: true
+      example: 52.379189
+      selector:
+        number:
+          min: -90
+          max: 90
+          step: any
+    longitude:
+      required: true
+      example: 4.899431
+      selector:
+        number:
+          min: -180
+          max: 180
+          step: any
+    accuracy:
+      required: true
+      example: 10
+      selector:
+        number:
+          min: 0
+          max: 10000
+          unit_of_measurement: m
+set_scanner_connected:
+  target:
+    entity:
+      integration: kitchen_sink
+      domain: device_tracker
+  fields:
+    connected:
+      required: true
+      example: true
+      selector:
+        boolean:

homeassistant/components/kitchen_sink/strings.json

@@ -135,6 +135,34 @@
     }
   },
   "services": {
+    "set_scanner_connected": {
+      "description": "Sets the connected state of a demo scanner entity.",
+      "fields": {
+        "connected": {
+          "description": "Whether the device should be reported as connected.",
+          "name": "Connected"
+        }
+      },
+      "name": "Set scanner connected"
+    },
+    "set_tracker_location": {
+      "description": "Sets the location and accuracy of a demo tracker entity.",
+      "fields": {
+        "accuracy": {
+          "description": "Location accuracy in meters.",
+          "name": "Accuracy"
+        },
+        "latitude": {
+          "description": "Latitude of the new location.",
+          "name": "Latitude"
+        },
+        "longitude": {
+          "description": "Longitude of the new location.",
+          "name": "Longitude"
+        }
+      },
+      "name": "Set tracker location"
+    },
     "test_service_1": {
       "description": "Fake action for testing {meep_2}",
       "fields": {

homeassistant/components/lg_tv_rs232/__init__.py

@@ -0,0 +1,52 @@
+"""The LG TV RS-232 integration."""
+
+from lg_rs232_tv import LGTV, TVState
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.const import CONF_DEVICE, Platform
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ConfigEntryNotReady
+
+from .const import CONF_SET_ID, LOGGER, QUERY_ATTRIBUTES, LGTVRS232ConfigEntry
+
+PLATFORMS = [Platform.MEDIA_PLAYER]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: LGTVRS232ConfigEntry) -> bool:
+    """Set up LG TV RS-232 from a config entry."""
+    port = entry.data[CONF_DEVICE]
+    tv = LGTV(port, set_id=entry.data[CONF_SET_ID])
+
+    try:
+        await tv.connect()
+        await tv.query(QUERY_ATTRIBUTES)
+    except (ConnectionError, OSError, TimeoutError) as err:
+        if tv.connected:
+            await tv.disconnect()
+        raise ConfigEntryNotReady(f"Error connecting to LG TV: {err}") from err
+
+    entry.runtime_data = tv
+
+    @callback
+    def _on_disconnect(state: TVState | None) -> None:
+        # Only reload if the entry is still loaded. During entry removal,
+        # disconnect() fires this callback but the entry is already gone.
+        if state is None and entry.state is ConfigEntryState.LOADED:
+            LOGGER.warning("LG TV disconnected, reloading config entry")
+            hass.config_entries.async_schedule_reload(entry.entry_id)
+
+    entry.async_on_unload(tv.subscribe(_on_disconnect))
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: LGTVRS232ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+    if unload_ok:
+        await entry.runtime_data.disconnect()
+
+    return unload_ok

homeassistant/components/lg_tv_rs232/config_flow.py

@@ -0,0 +1,102 @@
+"""Config flow for the LG TV RS-232 integration."""
+
+from typing import Any
+
+from lg_rs232_tv import DEFAULT_SET_ID, LGTV, TVNotRespondingError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_DEVICE
+from homeassistant.helpers.selector import (
+    NumberSelector,
+    NumberSelectorConfig,
+    NumberSelectorMode,
+    SerialPortSelector,
+)
+
+from .const import CONF_SET_ID, DOMAIN, LOGGER
+
+DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_DEVICE): SerialPortSelector(),
+        vol.Required(CONF_SET_ID, default=DEFAULT_SET_ID): NumberSelector(
+            NumberSelectorConfig(min=1, max=99, mode=NumberSelectorMode.BOX)
+        ),
+    }
+)
+
+# Outcome of _async_attempt_connect that means the serial port works but no LG
+# TV answered it; this routes the user to the troubleshooting step.
+RESULT_NO_TV = "no_tv"
+
+
+async def _async_attempt_connect(port: str, set_id: int) -> str | None:
+    """Attempt to connect to the TV at the given port.
+
+    Returns None on success, otherwise an outcome key: "cannot_connect" when
+    the serial port could not be opened, RESULT_NO_TV when the port works but
+    no LG TV responded to it, or "unknown" for an unexpected error.
+    """
+    tv = LGTV(port, set_id=set_id)
+
+    try:
+        await tv.connect()
+    except TVNotRespondingError:
+        # The port was opened but no LG TV responded to the power query.
+        return RESULT_NO_TV
+    except ValueError, ConnectionError, OSError, TimeoutError:
+        # The serial port itself could not be opened.
+        return "cannot_connect"
+    except Exception:  # noqa: BLE001
+        LOGGER.exception("Unexpected exception")
+        return "unknown"
+    else:
+        await tv.disconnect()
+        return None
+
+
+class LGTVRS232ConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for LG TV RS-232."""
+
+    VERSION = 1
+
+    _user_input: dict[str, Any] | None = None
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            port = user_input[CONF_DEVICE]
+            set_id = user_input[CONF_SET_ID]
+
+            self._async_abort_entries_match({CONF_DEVICE: port, CONF_SET_ID: set_id})
+            error = await _async_attempt_connect(port, set_id)
+            if error is None:
+                return self.async_create_entry(
+                    title="LG TV",
+                    data={CONF_DEVICE: port, CONF_SET_ID: set_id},
+                )
+            if error == RESULT_NO_TV:
+                self._user_input = user_input
+                return await self.async_step_troubleshoot()
+            errors["base"] = error
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                DATA_SCHEMA, user_input or self._user_input or {}
+            ),
+            errors=errors,
+        )
+
+    async def async_step_troubleshoot(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Guide the user to enable RS-232 control after a failed connection."""
+        if user_input is not None:
+            return await self.async_step_user()
+
+        return self.async_show_form(step_id="troubleshoot")

homeassistant/components/lg_tv_rs232/const.py

@@ -0,0 +1,18 @@
+"""Constants for the LG TV RS-232 integration."""
+
+import logging
+
+from lg_rs232_tv import LGTV
+
+from homeassistant.config_entries import ConfigEntry
+
+LOGGER = logging.getLogger(__package__)
+DOMAIN = "lg_tv_rs232"
+
+CONF_SET_ID = "set_id"
+
+# TVState attributes the integration polls for; the TV is not asked for
+# attributes the media player entity does not use.
+QUERY_ATTRIBUTES = ("power", "input_source", "volume", "volume_mute", "balance")
+
+type LGTVRS232ConfigEntry = ConfigEntry[LGTV]

homeassistant/components/lg_tv_rs232/manifest.json

@@ -0,0 +1,13 @@
+{
+  "domain": "lg_tv_rs232",
+  "name": "LG TV via Serial",
+  "codeowners": ["@balloob"],
+  "config_flow": true,
+  "dependencies": ["usb"],
+  "documentation": "https://www.home-assistant.io/integrations/lg_tv_rs232",
+  "integration_type": "device",
+  "iot_class": "local_polling",
+  "loggers": ["lg_rs232_tv"],
+  "quality_scale": "silver",
+  "requirements": ["lg-rs232-tv==1.2.0"]
+}

homeassistant/components/lg_tv_rs232/media_player.py

@@ -0,0 +1,186 @@
+"""Media player platform for the LG TV RS-232 integration."""
+
+from collections.abc import Callable, Coroutine
+from datetime import timedelta
+from functools import wraps
+from typing import Any
+
+from lg_rs232_tv import MAX_VOLUME, CommandRejected, InputSource, PowerState, TVState
+
+from homeassistant.components.media_player import (
+    MediaPlayerDeviceClass,
+    MediaPlayerEntity,
+    MediaPlayerEntityFeature,
+    MediaPlayerState,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN, QUERY_ATTRIBUTES, LGTVRS232ConfigEntry
+
+# LG TVs do not push state over RS-232, so the entity is polled.
+SCAN_INTERVAL = timedelta(seconds=5)
+PARALLEL_UPDATES = 1
+
+INPUT_SOURCE_LG_TO_HA: dict[InputSource, str] = {
+    InputSource.DTV_ANTENNA: "dtv_antenna",
+    InputSource.DTV_CABLE: "dtv_cable",
+    InputSource.ANALOG_ANTENNA: "analog_antenna",
+    InputSource.ANALOG_CABLE: "analog_cable",
+    InputSource.AV1: "av1",
+    InputSource.AV2: "av2",
+    InputSource.COMPONENT1: "component1",
+    InputSource.COMPONENT2: "component2",
+    InputSource.COMPONENT3: "component3",
+    InputSource.RGB_PC: "rgb_pc",
+    InputSource.HDMI1: "hdmi1",
+    InputSource.HDMI2: "hdmi2",
+    InputSource.HDMI3: "hdmi3",
+    InputSource.HDMI4: "hdmi4",
+}
+INPUT_SOURCE_HA_TO_LG: dict[str, InputSource] = {
+    value: key for key, value in INPUT_SOURCE_LG_TO_HA.items()
+}
+
+_BASE_SUPPORTED_FEATURES = (
+    MediaPlayerEntityFeature.TURN_ON
+    | MediaPlayerEntityFeature.TURN_OFF
+    | MediaPlayerEntityFeature.SELECT_SOURCE
+)
+
+
+def catch_command_errors[**_P](
+    func: Callable[_P, Coroutine[Any, Any, None]],
+) -> Callable[_P, Coroutine[Any, Any, None]]:
+    """Translate LG library errors raised by an action into HomeAssistantError."""
+
+    @wraps(func)
+    async def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> None:
+        try:
+            await func(*args, **kwargs)
+        except CommandRejected as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_rejected",
+                translation_placeholders={"error": str(err)},
+            ) from err
+        except (ConnectionError, OSError, TimeoutError) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_failed",
+                translation_placeholders={"error": str(err)},
+            ) from err
+
+    return wrapper
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: LGTVRS232ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the LG TV RS-232 media player."""
+    async_add_entities([LGTVRS232MediaPlayer(config_entry)])
+
+
+class LGTVRS232MediaPlayer(MediaPlayerEntity):
+    """Representation of an LG TV controlled over RS-232."""
+
+    _attr_device_class = MediaPlayerDeviceClass.TV
+    _attr_has_entity_name = True
+    _attr_name = None
+    _attr_translation_key = "tv"
+    _attr_source_list = sorted(INPUT_SOURCE_LG_TO_HA.values())
+
+    def __init__(self, config_entry: LGTVRS232ConfigEntry) -> None:
+        """Initialize the media player."""
+        self._tv = config_entry.runtime_data
+        self._attr_unique_id = config_entry.entry_id
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, config_entry.entry_id)},
+            manufacturer="LG",
+        )
+        self._async_update_from_state(self._tv.state)
+
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to TV state updates."""
+        self.async_on_remove(self._tv.subscribe(self._async_on_state_update))
+
+    async def async_update(self) -> None:
+        """Poll the TV for its current state."""
+        await self._tv.query(QUERY_ATTRIBUTES)
+
+    @callback
+    def _async_on_state_update(self, state: TVState | None) -> None:
+        """Handle a state update from the TV."""
+        if state is None:
+            self._attr_available = False
+        else:
+            self._attr_available = True
+            self._async_update_from_state(state)
+        self.async_write_ha_state()
+
+    @callback
+    def _async_update_from_state(self, state: TVState) -> None:
+        """Update entity attributes from a TV state snapshot."""
+        if state.power is None:
+            self._attr_state = None
+        else:
+            self._attr_state = (
+                MediaPlayerState.ON
+                if state.power is PowerState.ON
+                else MediaPlayerState.OFF
+            )
+
+        source = state.input_source
+        self._attr_source = INPUT_SOURCE_LG_TO_HA.get(source) if source else None
+
+        # The TV only answers the balance query when its own speaker is the
+        # active audio output. When audio is routed elsewhere (e.g. optical),
+        # the TV's volume does not reflect what the user hears, so neither the
+        # volume controls nor the volume attributes are exposed.
+        features = _BASE_SUPPORTED_FEATURES
+        if state.balance is None:
+            self._attr_volume_level = None
+            self._attr_is_volume_muted = None
+        else:
+            features |= (
+                MediaPlayerEntityFeature.VOLUME_SET
+                | MediaPlayerEntityFeature.VOLUME_STEP
+                | MediaPlayerEntityFeature.VOLUME_MUTE
+            )
+            self._attr_volume_level = (
+                None if state.volume is None else state.volume / MAX_VOLUME
+            )
+            self._attr_is_volume_muted = state.volume_mute
+        self._attr_supported_features = features
+
+    @catch_command_errors
+    async def async_turn_on(self) -> None:
+        """Turn the TV on."""
+        await self._tv.power_on()
+
+    @catch_command_errors
+    async def async_turn_off(self) -> None:
+        """Turn the TV off."""
+        await self._tv.power_off()
+
+    @catch_command_errors
+    async def async_set_volume_level(self, volume: float) -> None:
+        """Set volume level, range 0..1."""
+        await self._tv.set_volume(round(volume * MAX_VOLUME))
+
+    @catch_command_errors
+    async def async_mute_volume(self, mute: bool) -> None:
+        """Mute or unmute the TV."""
+        if mute:
+            await self._tv.mute_on()
+        else:
+            await self._tv.mute_off()
+
+    @catch_command_errors
+    async def async_select_source(self, source: str) -> None:
+        """Select an input source."""
+        await self._tv.select_input_source(INPUT_SOURCE_HA_TO_LG[source])

homeassistant/components/lg_tv_rs232/quality_scale.yaml

@@ -0,0 +1,84 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: The integration does not register custom actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: The integration does not register custom actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: done
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: The integration has no options to configure.
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow:
+    status: exempt
+    comment: The integration does not require authentication.
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: Serial devices are configured manually; there is no discovery.
+  discovery:
+    status: exempt
+    comment: RS-232 serial connections cannot be discovered.
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices:
+    status: exempt
+    comment: The integration does not create dynamic devices.
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default:
+    status: exempt
+    comment: The integration only provides a single primary entity.
+  entity-translations: done
+  exception-translations: todo
+  icon-translations:
+    status: exempt
+    comment: The media player entity uses its device class for its icon.
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: The integration has no user-actionable issues to repair.
+  stale-devices:
+    status: exempt
+    comment: The integration does not create devices that can become stale.
+
+  # Platinum
+  async-dependency: done
+  inject-websession:
+    status: exempt
+    comment: The integration does not make HTTP requests.
+  strict-typing: done

homeassistant/components/lg_tv_rs232/strings.json

@@ -0,0 +1,61 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "troubleshoot": {
+        "description": "Home Assistant could not communicate with the LG TV over the serial port.\n\nThe most common cause is that **RS-232C Control** is not enabled on the TV. On most LG models this setting is in a hidden service menu (often called **InStart**); the exact location varies by model, so check your TV's documentation.\n\nAlso make sure that:\n- The TV is powered on.\n- The serial cable is a null-modem (cross-over) cable and is fully seated. LG's RS-232 jack is recessed, so push the plug in until it clicks.\n- The correct serial port was selected.\n\nSelect **Submit** to try again.",
+        "title": "Connection failed"
+      },
+      "user": {
+        "data": {
+          "device": "[%key:common::config_flow::data::port%]",
+          "set_id": "Set ID"
+        },
+        "data_description": {
+          "device": "Serial port path to connect to. The TV must be powered on for the initial connection.",
+          "set_id": "The set ID configured on the TV. Leave this at 1 unless you have multiple TVs daisy-chained on the same RS-232 bus."
+        }
+      }
+    }
+  },
+  "entity": {
+    "media_player": {
+      "tv": {
+        "state_attributes": {
+          "source": {
+            "state": {
+              "analog_antenna": "Analog (antenna)",
+              "analog_cable": "Analog (cable)",
+              "av1": "AV 1",
+              "av2": "AV 2",
+              "component1": "Component 1",
+              "component2": "Component 2",
+              "component3": "Component 3",
+              "dtv_antenna": "Digital TV (antenna)",
+              "dtv_cable": "Digital TV (cable)",
+              "hdmi1": "HDMI 1",
+              "hdmi2": "HDMI 2",
+              "hdmi3": "HDMI 3",
+              "hdmi4": "HDMI 4",
+              "rgb_pc": "RGB PC"
+            }
+          }
+        }
+      }
+    }
+  },
+  "exceptions": {
+    "command_failed": {
+      "message": "Failed to send the command to the TV: {error}"
+    },
+    "command_rejected": {
+      "message": "The TV rejected the command: {error}"
+    }
+  }
+}

homeassistant/components/lyric/__init__.py

@@ -21,7 +21,7 @@ from .coordinator import LyricConfigEntry, LyricDataUpdateCoordinator
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
-PLATFORMS = [Platform.CLIMATE, Platform.SENSOR]
+PLATFORMS = [Platform.CLIMATE, Platform.SELECT, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: LyricConfigEntry) -> bool:

homeassistant/components/lyric/icons.json

@@ -1,5 +1,10 @@
 {
   "entity": {
+    "select": {
+      "room_priority": {
+        "default": "mdi:home-thermometer"
+      }
+    },
     "sensor": {
       "setpoint_status": {
         "default": "mdi:thermostat"

homeassistant/components/lyric/select.py

@@ -0,0 +1,129 @@
+"""Support for Honeywell Lyric select platform."""
+
+import logging
+
+from aiolyric.objects.device import LyricDevice
+from aiolyric.objects.location import LyricLocation
+from aiolyric.objects.priority import LyricRoom
+
+from homeassistant.components.select import SelectEntity
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import LYRIC_EXCEPTIONS
+from .coordinator import LyricConfigEntry, LyricDataUpdateCoordinator
+from .entity import LyricDeviceEntity
+
+_LOGGER = logging.getLogger(__name__)
+
+# Honeywell Lyric API priority types
+PRIORITY_TYPE_PICK_A_ROOM = "PickARoom"
+PRIORITY_TYPE_FOLLOW_ME = "FollowMe"
+PRIORITY_TYPE_WHOLE_HOUSE = "WholeHouse"
+
+# Option shown in the select for the FollowMe mode
+OPTION_FOLLOW_ME = "follow_me"
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: LyricConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Honeywell Lyric select entities based on a config entry."""
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        LyricRoomPrioritySelect(coordinator, location, device)
+        for location in coordinator.data.locations
+        for device in location.devices
+        if device.device_class == "Thermostat"
+        and device.device_id.startswith("LCC")
+        and coordinator.data.rooms_dict.get(device.mac_id)
+    )
+
+
+class LyricRoomPrioritySelect(LyricDeviceEntity, SelectEntity):
+    """Select entity for Honeywell Lyric thermostat room priority."""
+
+    _attr_entity_category = EntityCategory.CONFIG
+    _attr_translation_key = "room_priority"
+
+    def __init__(
+        self,
+        coordinator: LyricDataUpdateCoordinator,
+        location: LyricLocation,
+        device: LyricDevice,
+    ) -> None:
+        """Initialize the room priority select entity."""
+        super().__init__(
+            coordinator,
+            location,
+            device,
+            f"{device.mac_id}_room_priority",
+        )
+
+    @property
+    def _rooms(self) -> dict[int, LyricRoom]:
+        """Return the rooms for this thermostat."""
+        return self.coordinator.data.rooms_dict.get(self._mac_id, {})
+
+    @property
+    def options(self) -> list[str]:
+        """Return the list of available room priority options."""
+        room_options = sorted(
+            room.room_name for room in self._rooms.values() if room.room_name
+        )
+        return [OPTION_FOLLOW_ME, *room_options]
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the currently selected room priority."""
+        priority = self.coordinator.data.priorities_dict.get(self._mac_id)
+        if priority is None:
+            return None
+
+        current = priority.current_priority
+        if current.priority_type == PRIORITY_TYPE_FOLLOW_ME:
+            return OPTION_FOLLOW_ME
+
+        if current.priority_type == PRIORITY_TYPE_PICK_A_ROOM:
+            selected = current.selected_rooms
+            if selected:
+                room = self._rooms.get(selected[0])
+                if room is not None:
+                    return room.room_name
+
+        return None
+
+    async def async_select_option(self, option: str) -> None:
+        """Set the room priority."""
+        if option == OPTION_FOLLOW_ME:
+            priority_type = PRIORITY_TYPE_FOLLOW_ME
+            rooms: list[int] = []
+        else:
+            priority_type = PRIORITY_TYPE_PICK_A_ROOM
+            room_id = next(
+                (rid for rid, room in self._rooms.items() if room.room_name == option),
+                None,
+            )
+            if room_id is None:
+                _LOGGER.error("Room not found: %s", option)
+                return
+            rooms = [room_id]
+
+        _LOGGER.debug("Set room priority: type=%s, rooms=%s", priority_type, rooms)
+        try:
+            await self.coordinator.data.update_priority(
+                self.location,
+                self.device,
+                priority_type=priority_type,
+                rooms=rooms,
+            )
+        except LYRIC_EXCEPTIONS as exception:
+            raise HomeAssistantError(
+                f"Failed to set room priority: {exception}"
+            ) from exception
+        await self.coordinator.async_refresh()

homeassistant/components/lyric/strings.json

@@ -37,6 +37,14 @@
     }
   },
   "entity": {
+    "select": {
+      "room_priority": {
+        "name": "Room priority",
+        "state": {
+          "follow_me": "Follow me"
+        }
+      }
+    },
     "sensor": {
       "indoor_humidity": {
         "name": "Indoor humidity"

homeassistant/components/madvr/__init__.py

@@ -27,7 +27,7 @@ async def async_handle_unload(coordinator: MadVRCoordinator) -> None:
 async def async_setup_entry(hass: HomeAssistant, entry: MadVRConfigEntry) -> bool:
     """Set up the integration from a config entry."""
     assert entry.unique_id
-    madVRClient = Madvr(
+    mad_vr_client = Madvr(
         host=entry.data[CONF_HOST],
         logger=_LOGGER,
         port=entry.data[CONF_PORT],
@@ -35,7 +35,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: MadVRConfigEntry) -> boo
         connect_timeout=10,
         loop=hass.loop,
     )
-    coordinator = MadVRCoordinator(hass, entry, madVRClient)
+    coordinator = MadVRCoordinator(hass, entry, mad_vr_client)
 
     entry.runtime_data = coordinator
 

homeassistant/components/mastodon/const.py

@@ -29,8 +29,10 @@ ATTR_DISPLAY_NAME = "display_name"
 ATTR_NOTE = "note"
 ATTR_AVATAR = "avatar"
 ATTR_AVATAR_MIME_TYPE = "avatar_mime_type"
+ATTR_DELETE_AVATAR = "delete_avatar"
 ATTR_HEADER = "header"
 ATTR_HEADER_MIME_TYPE = "header_mime_type"
+ATTR_DELETE_HEADER = "delete_header"
 ATTR_BOT = "bot"
 ATTR_DISCOVERABLE = "discoverable"
 ATTR_FIELDS = "fields"

homeassistant/components/mastodon/services.py

@@ -38,6 +38,8 @@ from .const import (
     ATTR_AVATAR_MIME_TYPE,
     ATTR_BOT,
     ATTR_CONTENT_WARNING,
+    ATTR_DELETE_AVATAR,
+    ATTR_DELETE_HEADER,
     ATTR_DISCOVERABLE,
     ATTR_DISPLAY_NAME,
     ATTR_DURATION,
@@ -133,8 +135,10 @@ SERVICE_UPDATE_PROFILE_SCHEMA = vol.Schema(
         vol.Required(ATTR_CONFIG_ENTRY_ID): str,
         vol.Optional(ATTR_DISPLAY_NAME): str,
         vol.Optional(ATTR_NOTE): str,
-        vol.Optional(ATTR_AVATAR): MediaSelector({"accept": ["image/*"]}),
-        vol.Optional(ATTR_HEADER): MediaSelector({"accept": ["image/*"]}),
+        vol.Exclusive(ATTR_AVATAR, ATTR_AVATAR): MediaSelector({"accept": ["image/*"]}),
+        vol.Exclusive(ATTR_DELETE_AVATAR, ATTR_AVATAR): cv.boolean,
+        vol.Exclusive(ATTR_HEADER, ATTR_HEADER): MediaSelector({"accept": ["image/*"]}),
+        vol.Exclusive(ATTR_DELETE_HEADER, ATTR_HEADER): cv.boolean,
         vol.Optional(ATTR_LOCKED): bool,
         vol.Optional(ATTR_BOT): bool,
         vol.Optional(ATTR_DISCOVERABLE): bool,
@@ -404,9 +408,21 @@ async def _async_update_profile(call: ServiceCall) -> ServiceResponse | None:
             for field in fields
             if field[ATTR_NAME].strip()
         ]
+    delete_avatar = params.pop("delete_avatar", False)
+    delete_header = params.pop("delete_header", False)
     try:
-        response: Account = await call.hass.async_add_executor_job(
-            lambda: client.account_update_credentials(**params)
+
+        def _update_profile() -> Any:
+            if delete_avatar:
+                client.account_delete_avatar()
+            if delete_header:
+                client.account_delete_header()
+            if call.return_response or params:
+                return client.account_update_credentials(**params)
+            return None
+
+        response: Account | None = await call.hass.async_add_executor_job(
+            _update_profile
         )
     except MastodonUnauthorizedError as error:
         entry.async_start_reauth(call.hass)

homeassistant/components/mastodon/services.yaml

@@ -294,12 +294,24 @@ update_profile:
         media:
           accept:
             - "image/*"
+    delete_avatar:
+      required: false
+      selector:
+        constant:
+          value: true
+          label: ""
     header:
       required: false
       selector:
         media:
           accept:
             - "image/*"
+    delete_header:
+      required: false
+      selector:
+        constant:
+          value: true
+          label: ""
     locked:
       selector:
         boolean:

homeassistant/components/mastodon/strings.json

@@ -283,6 +283,14 @@
           "description": "Select the Mastodon account to update the profile of.",
           "name": "[%key:component::mastodon::services::post::fields::config_entry_id::name%]"
         },
+        "delete_avatar": {
+          "description": "Permanently removes your current profile picture.",
+          "name": "Delete profile picture"
+        },
+        "delete_header": {
+          "description": "Permanently removes your current header picture.",
+          "name": "Delete header picture"
+        },
         "discoverable": {
           "description": "Whether your profile should be discoverable. Public posts and the profile may be featured or recommended across Mastodon.",
           "name": "Discoverable"

homeassistant/components/microbees/cover.py

@@ -84,12 +84,12 @@ class MBCover(MicroBeesEntity, CoverEntity):
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Open the cover."""
-        sendCommand = await self.coordinator.microbees.sendCommand(
+        send_command = await self.coordinator.microbees.sendCommand(
             self.actuator_up_id,
             self.actuator_up.configuration.actuator_timing * 1000,
         )
 
-        if not sendCommand:
+        if not send_command:
             raise HomeAssistantError(f"Failed to open {self.name}")
 
         self._attr_is_opening = True
@@ -101,11 +101,11 @@ class MBCover(MicroBeesEntity, CoverEntity):
 
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover."""
-        sendCommand = await self.coordinator.microbees.sendCommand(
+        send_command = await self.coordinator.microbees.sendCommand(
             self.actuator_down_id,
             self.actuator_down.configuration.actuator_timing * 1000,
         )
-        if not sendCommand:
+        if not send_command:
             raise HomeAssistantError(f"Failed to close {self.name}")
 
         self._attr_is_closing = True

homeassistant/components/microbees/light.py

@@ -56,10 +56,10 @@ class MBLight(MicroBeesActuatorEntity, LightEntity):
         """Turn on the light."""
         if ATTR_RGBW_COLOR in kwargs:
             self._attr_rgbw_color = kwargs[ATTR_RGBW_COLOR]
-        sendCommand = await self.coordinator.microbees.sendCommand(
+        send_command = await self.coordinator.microbees.sendCommand(
             self.actuator_id, 1, color=self._attr_rgbw_color
         )
-        if not sendCommand:
+        if not send_command:
             raise HomeAssistantError(f"Failed to turn on {self.name}")
 
         self.actuator.value = True
@@ -67,10 +67,10 @@ class MBLight(MicroBeesActuatorEntity, LightEntity):
 
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn off the light."""
-        sendCommand = await self.coordinator.microbees.sendCommand(
+        send_command = await self.coordinator.microbees.sendCommand(
             self.actuator_id, 0, color=self._attr_rgbw_color
         )
-        if not sendCommand:
+        if not send_command:
             raise HomeAssistantError(f"Failed to turn off {self.name}")
 
         self.actuator.value = False

homeassistant/components/mobile_app/notify.py

@@ -152,8 +152,8 @@ def log_rate_limits(device_name, resp, level=logging.INFO):
         return
 
     rate_limits = resp[ATTR_PUSH_RATE_LIMITS]
-    resetsAt = rate_limits[ATTR_PUSH_RATE_LIMITS_RESETS_AT]
-    resetsAtTime = dt_util.parse_datetime(resetsAt) - dt_util.utcnow()
+    resets_at = rate_limits[ATTR_PUSH_RATE_LIMITS_RESETS_AT]
+    resets_at_time = dt_util.parse_datetime(resets_at) - dt_util.utcnow()
     rate_limit_msg = (
         "mobile_app push notification rate limits for %s: "
         "%d sent, %d allowed, %d errors, "
@@ -166,7 +166,7 @@ def log_rate_limits(device_name, resp, level=logging.INFO):
         rate_limits[ATTR_PUSH_RATE_LIMITS_SUCCESSFUL],
         rate_limits[ATTR_PUSH_RATE_LIMITS_MAXIMUM],
         rate_limits[ATTR_PUSH_RATE_LIMITS_ERRORS],
-        str(resetsAtTime).split(".", maxsplit=1)[0],
+        str(resets_at_time).split(".", maxsplit=1)[0],
     )
 
 

homeassistant/components/opensensemap/__init__.py

@@ -1 +1,41 @@
-"""The opensensemap component."""
+"""The openSenseMap integration."""
+
+from opensensemap_api import OpenSenseMap
+from opensensemap_api.exceptions import OpenSenseMapError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import CONF_STATION_ID
+
+PLATFORMS: list[Platform] = [Platform.AIR_QUALITY]
+
+type OpenSenseMapConfigEntry = ConfigEntry[OpenSenseMap]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: OpenSenseMapConfigEntry
+) -> bool:
+    """Set up openSenseMap from a config entry."""
+    session = async_get_clientsession(hass)
+    api = OpenSenseMap(entry.data[CONF_STATION_ID], session)
+    try:
+        await api.get_data()
+    except OpenSenseMapError as err:
+        raise ConfigEntryNotReady(
+            f"Unable to fetch data from openSenseMap: {err}"
+        ) from err
+
+    entry.runtime_data = api
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, entry: OpenSenseMapConfigEntry
+) -> bool:
+    """Unload an openSenseMap config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/opensensemap/air_quality.py

@@ -1,7 +1,6 @@
 """Support for openSenseMap Air Quality data."""
 
 from datetime import timedelta
-import logging
 
 from opensensemap_api import OpenSenseMap
 from opensensemap_api.exceptions import OpenSenseMapError
@@ -11,19 +10,26 @@ from homeassistant.components.air_quality import (
     PLATFORM_SCHEMA as AIR_QUALITY_PLATFORM_SCHEMA,
     AirQualityEntity,
 )
+from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import CONF_NAME
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import PlatformNotReady
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
+from homeassistant.data_entry_flow import FlowResultType
+from homeassistant.helpers import config_validation as cv, issue_registry as ir
+from homeassistant.helpers.entity_platform import (
+    AddConfigEntryEntitiesCallback,
+    AddEntitiesCallback,
+)
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
-from homeassistant.util import Throttle
 
-_LOGGER = logging.getLogger(__name__)
-
-
-CONF_STATION_ID = "station_id"
+from . import OpenSenseMapConfigEntry
+from .const import (
+    CONF_STATION_ID,
+    DEPRECATED_YAML_BREAKS_IN_VERSION,
+    DOMAIN,
+    INTEGRATION_TITLE,
+    KNOWN_IMPORT_ABORT_REASONS,
+    LOGGER,
+)
 
 SCAN_INTERVAL = timedelta(minutes=10)
 
@@ -38,23 +44,67 @@ async def async_setup_platform(
     async_add_entities: AddEntitiesCallback,
     discovery_info: DiscoveryInfoType | None = None,
 ) -> None:
-    """Set up the openSenseMap air quality platform."""
+    """Import legacy YAML configuration into a config entry."""
+    # Keep the legacy platform entry point so existing YAML is migrated into a
+    # config entry instead of adding entities directly from YAML.
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_IMPORT},
+        data=config,
+    )
 
-    name = config.get(CONF_NAME)
-    station_id = config[CONF_STATION_ID]
+    if (
+        result["type"] is FlowResultType.ABORT
+        and result["reason"] in KNOWN_IMPORT_ABORT_REASONS
+    ):
+        # Per-reason issue conveys the deprecation notice itself, so don't also
+        # raise the generic deprecated_yaml issue on top of it.
+        ir.async_create_issue(
+            hass,
+            DOMAIN,
+            f"deprecated_yaml_import_issue_{result['reason']}",
+            breaks_in_ha_version=DEPRECATED_YAML_BREAKS_IN_VERSION,
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key=f"deprecated_yaml_import_issue_{result['reason']}",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": INTEGRATION_TITLE,
+            },
+        )
+        return
 
-    session = async_get_clientsession(hass)
-    osm_api = OpenSenseMapData(OpenSenseMap(station_id, session))
+    # "deprecated_yaml" translation key lives under the "homeassistant" core domain.
+    ir.async_create_issue(
+        hass,
+        HOMEASSISTANT_DOMAIN,
+        f"deprecated_yaml_{DOMAIN}",
+        breaks_in_ha_version=DEPRECATED_YAML_BREAKS_IN_VERSION,
+        is_fixable=False,
+        issue_domain=DOMAIN,
+        severity=ir.IssueSeverity.WARNING,
+        translation_key="deprecated_yaml",
+        translation_placeholders={
+            "domain": DOMAIN,
+            "integration_title": INTEGRATION_TITLE,
+        },
+    )
 
-    await osm_api.async_update()
 
-    if "name" not in osm_api.api.data:
-        _LOGGER.error("Station %s is not available", station_id)
-        raise PlatformNotReady
-
-    station_name = osm_api.api.data["name"] if name is None else name
-
-    async_add_entities([OpenSenseMapQuality(station_name, osm_api)], True)
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: OpenSenseMapConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the openSenseMap air quality entity from a config entry."""
+    async_add_entities(
+        [
+            OpenSenseMapQuality(
+                entry.runtime_data, entry.data[CONF_STATION_ID], entry.title
+            )
+        ]
+    )
 
 
 class OpenSenseMapQuality(AirQualityEntity):
@@ -62,43 +112,28 @@ class OpenSenseMapQuality(AirQualityEntity):
 
     _attr_attribution = "Data provided by openSenseMap"
 
-    def __init__(self, name, osm):
+    def __init__(self, api: OpenSenseMap, station_id: str, name: str) -> None:
         """Initialize the air quality entity."""
-        self._name = name
-        self._osm = osm
+        self._api = api
+        self._attr_name = name
+        self._attr_unique_id = station_id
 
     @property
-    def name(self):
-        """Return the name of the air quality entity."""
-        return self._name
-
-    @property
-    def particulate_matter_2_5(self):
+    def particulate_matter_2_5(self) -> float | None:
         """Return the particulate matter 2.5 level."""
-        return self._osm.api.pm2_5
+        return self._api.pm2_5
 
     @property
-    def particulate_matter_10(self):
+    def particulate_matter_10(self) -> float | None:
         """Return the particulate matter 10 level."""
-        return self._osm.api.pm10
-
-    async def async_update(self):
-        """Get the latest data from the openSenseMap API."""
-        await self._osm.async_update()
-
-
-class OpenSenseMapData:
-    """Get the latest data and update the states."""
-
-    def __init__(self, api):
-        """Initialize the data object."""
-        self.api = api
-
-    @Throttle(SCAN_INTERVAL)
-    async def async_update(self):
-        """Get the latest data from the Pi-hole."""
+        return self._api.pm10
 
+    async def async_update(self) -> None:
+        """Fetch latest data from the openSenseMap API."""
         try:
-            await self.api.get_data()
+            await self._api.get_data()
         except OpenSenseMapError as err:
-            _LOGGER.error("Unable to fetch data: %s", err)
+            LOGGER.warning("Unable to fetch data from openSenseMap: %s", err)
+            self._attr_available = False
+        else:
+            self._attr_available = True

homeassistant/components/opensensemap/config_flow.py

@@ -0,0 +1,89 @@
+"""Config flow for the openSenseMap integration."""
+
+from typing import Any
+
+from opensensemap_api import OpenSenseMap
+from opensensemap_api.exceptions import OpenSenseMapError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_NAME
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import CONF_STATION_ID, DOMAIN, ERROR_CANNOT_CONNECT, ERROR_INVALID_STATION
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate the openSenseMap API is unreachable."""
+
+
+class InvalidStation(HomeAssistantError):
+    """Error to indicate the station ID does not exist."""
+
+
+class OpenSenseMapConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for openSenseMap."""
+
+    VERSION = 1
+
+    async def _async_get_station_name(self, station_id: str) -> str:
+        """Validate the station ID and return its name."""
+        session = async_get_clientsession(self.hass)
+        api = OpenSenseMap(station_id, session)
+        try:
+            # opensensemap_api wraps the request in a 5s aiohttp.ClientTimeout
+            # and re-raises asyncio.TimeoutError as OpenSenseMapConnectionError.
+            await api.get_data()
+        except OpenSenseMapError as err:
+            raise CannotConnect from err
+        if not api.data or not api.data.get("name"):
+            raise InvalidStation
+        return api.data["name"]
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a user-initiated config flow."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            station_id = user_input[CONF_STATION_ID]
+            try:
+                name = await self._async_get_station_name(station_id)
+            except CannotConnect:
+                errors["base"] = ERROR_CANNOT_CONNECT
+            except InvalidStation:
+                errors["base"] = ERROR_INVALID_STATION
+            else:
+                await self.async_set_unique_id(station_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=name,
+                    data={CONF_STATION_ID: station_id},
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema({vol.Required(CONF_STATION_ID): str}),
+            errors=errors,
+        )
+
+    async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
+        """Handle import of a YAML configuration."""
+        station_id = import_data[CONF_STATION_ID]
+        await self.async_set_unique_id(station_id)
+        self._abort_if_unique_id_configured()
+
+        # Even when YAML provides a display name, validate the station before
+        # migrating so broken YAML does not create an entry that cannot set up.
+        try:
+            name = await self._async_get_station_name(station_id)
+        except CannotConnect:
+            return self.async_abort(reason=ERROR_CANNOT_CONNECT)
+        except InvalidStation:
+            return self.async_abort(reason=ERROR_INVALID_STATION)
+
+        return self.async_create_entry(
+            title=import_data.get(CONF_NAME) or name,
+            data={CONF_STATION_ID: station_id},
+        )

homeassistant/components/opensensemap/const.py

@@ -0,0 +1,16 @@
+"""Constants for the openSenseMap integration."""
+
+import logging
+
+DOMAIN = "opensensemap"
+
+LOGGER = logging.getLogger(__name__)
+
+CONF_STATION_ID = "station_id"
+
+INTEGRATION_TITLE = "openSenseMap"
+DEPRECATED_YAML_BREAKS_IN_VERSION = "2026.12.0"
+
+ERROR_CANNOT_CONNECT = "cannot_connect"
+ERROR_INVALID_STATION = "invalid_station"
+KNOWN_IMPORT_ABORT_REASONS = (ERROR_CANNOT_CONNECT, ERROR_INVALID_STATION)

homeassistant/components/opensensemap/manifest.json

@@ -1,8 +1,10 @@
 {
   "domain": "opensensemap",
   "name": "openSenseMap",
-  "codeowners": [],
+  "codeowners": ["@AlCalzone"],
+  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/opensensemap",
+  "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["opensensemap_api"],
   "quality_scale": "legacy",

homeassistant/components/opensensemap/strings.json

@@ -0,0 +1,35 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+      "cannot_connect": "Failed to connect to openSenseMap.",
+      "invalid_station": "The provided station ID does not exist on openSenseMap."
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_station": "[%key:component::opensensemap::config::abort::invalid_station%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "station_id": "Station ID"
+        },
+        "data_description": {
+          "station_id": "The unique identifier of your openSenseMap station. You can find it in the URL when viewing the station on opensensemap.org."
+        },
+        "description": "Add an openSenseMap station to monitor its measurements.",
+        "title": "Add openSenseMap station"
+      }
+    }
+  },
+  "issues": {
+    "deprecated_yaml_import_issue_cannot_connect": {
+      "description": "Configuring {integration_title} using YAML is being removed but there was a connection error importing your YAML configuration.\n\nEnsure connection to {integration_title} works and restart Home Assistant to try again or remove the {integration_title} YAML configuration from your configuration.yaml file and continue to set up the integration manually.",
+      "title": "The {integration_title} YAML configuration import failed"
+    },
+    "deprecated_yaml_import_issue_invalid_station": {
+      "description": "Configuring {integration_title} using YAML is being removed but the configured station could not be found.\n\nVerify the station ID and restart Home Assistant to try again or remove the {integration_title} YAML configuration from your configuration.yaml file and continue to set up the integration manually.",
+      "title": "[%key:component::opensensemap::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
+    }
+  }
+}

homeassistant/components/opnsense/__init__.py

@@ -1,7 +1,5 @@
 """Support for OPNsense Routers."""
 
-import logging
-
 from aiopnsense import (
     OPNsenseBelowMinFirmware,
     OPNsenseClient,
@@ -15,22 +13,16 @@ from aiopnsense import (
 )
 import voluptuous as vol
 
+from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.const import CONF_API_KEY, CONF_URL, CONF_VERIFY_SSL, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv
+from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.discovery import load_platform
+import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 
-from .const import (
-    CONF_API_SECRET,
-    CONF_INTERFACE_CLIENT,
-    CONF_TRACKER_INTERFACES,
-    DOMAIN,
-    OPNSENSE_DATA,
-)
-
-_LOGGER = logging.getLogger(__name__)
+from .const import CONF_API_SECRET, CONF_TRACKER_INTERFACES, DOMAIN
+from .types import OPNsenseConfigEntry, OPNsenseRuntimeData
 
 CONFIG_SCHEMA = vol.Schema(
     {
@@ -49,86 +41,124 @@ CONFIG_SCHEMA = vol.Schema(
     extra=vol.ALLOW_EXTRA,
 )
 
+PLATFORMS = [Platform.DEVICE_TRACKER]
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the opnsense component."""
+    """Set up the OPNsense component."""
+    if DOMAIN not in config:
+        return True
 
-    conf = config[DOMAIN]
-    url = conf[CONF_URL]
-    api_key = conf[CONF_API_KEY]
-    api_secret = conf[CONF_API_SECRET]
-    verify_ssl = conf[CONF_VERIFY_SSL]
-    tracker_interfaces = conf[CONF_TRACKER_INTERFACES]
+    hass.async_create_task(_async_setup(hass, config))
 
-    session = async_get_clientsession(hass, verify_ssl=verify_ssl)
+    return True
+
+
+async def _async_setup(hass: HomeAssistant, config: ConfigType) -> None:
+    """Set up the OPNsense component from YAML."""
+    await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_IMPORT},
+        data=config[DOMAIN],
+    )
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, config_entry: OPNsenseConfigEntry
+) -> bool:
+    """Set up the OPNsense component from a config entry."""
+    url = config_entry.data[CONF_URL]
+    session = async_get_clientsession(
+        hass, verify_ssl=config_entry.data[CONF_VERIFY_SSL]
+    )
     client = OPNsenseClient(
         url,
-        api_key,
-        api_secret,
+        config_entry.data[CONF_API_KEY],
+        config_entry.data[CONF_API_SECRET],
         session,
-        opts={"verify_ssl": verify_ssl},
+        opts={"verify_ssl": config_entry.data[CONF_VERIFY_SSL]},
     )
+    tracker_interfaces = config_entry.data.get(CONF_TRACKER_INTERFACES, [])
     try:
         await client.validate()
         if tracker_interfaces:
             interfaces_resp = await client.get_interfaces()
-    except OPNsenseUnknownFirmware:
-        _LOGGER.error("Error checking the OPNsense firmware version at %s", url)
-        return False
-    except OPNsenseBelowMinFirmware:
-        _LOGGER.error(
-            "OPNsense Firmware is below the minimum supported version at %s", url
-        )
-        return False
-    except OPNsenseInvalidURL:
-        _LOGGER.error(
-            "Invalid URL while connecting to OPNsense API endpoint at %s", url
-        )
-        return False
-    except OPNsenseTimeoutError:
-        _LOGGER.error("Timeout while connecting to OPNsense API endpoint at %s", url)
-        return False
-    except OPNsenseSSLError:
-        _LOGGER.error(
-            "Unable to verify SSL while connecting to OPNsense API endpoint at %s", url
-        )
-        return False
-    except OPNsenseInvalidAuth:
-        _LOGGER.error(
-            "Authentication failure while connecting to OPNsense API endpoint at %s",
-            url,
-        )
-        return False
-    except OPNsensePrivilegeMissing:
-        _LOGGER.error(
-            "Invalid Permissions while connecting to OPNsense API endpoint at %s",
-            url,
-        )
-        return False
-    except OPNsenseConnectionError:
-        _LOGGER.error(
-            "Connection failure while connecting to OPNsense API endpoint at %s",
-            url,
-        )
-        return False
+    except OPNsenseUnknownFirmware as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="unknown_firmware",
+            translation_placeholders={"url": url},
+        ) from err
+    except OPNsenseBelowMinFirmware as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="firmware_too_old",
+            translation_placeholders={"url": url},
+        ) from err
+    except OPNsenseInvalidURL as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_url",
+            translation_placeholders={"url": url},
+        ) from err
+    except OPNsenseTimeoutError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="timeout_connecting",
+            translation_placeholders={"url": url},
+        ) from err
+    except OPNsenseSSLError as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="ssl_error",
+            translation_placeholders={"url": url},
+        ) from err
+    except OPNsenseInvalidAuth as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_auth",
+            translation_placeholders={"url": url},
+        ) from err
+    except OPNsensePrivilegeMissing as err:
+        raise ConfigEntryError(
+            translation_domain=DOMAIN,
+            translation_key="privilege_missing",
+            translation_placeholders={"url": url},
+        ) from err
+    except OPNsenseConnectionError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="cannot_connect",
+            translation_placeholders={"url": url},
+        ) from err
 
     if tracker_interfaces:
         # Verify that specified tracker interfaces are valid
         known_interfaces = [
-            ifinfo.get("name", "") for ifinfo in interfaces_resp.values()
+            name for ifinfo in interfaces_resp.values() if (name := ifinfo.get("name"))
         ]
         for intf_description in tracker_interfaces:
             if intf_description not in known_interfaces:
-                _LOGGER.error(
-                    "Specified OPNsense tracker interface %s is not found",
-                    intf_description,
+                raise ConfigEntryError(
+                    translation_domain=DOMAIN,
+                    translation_key="tracker_interface_not_found",
+                    translation_placeholders={
+                        "interface": intf_description,
+                        "known": ", ".join(known_interfaces),
+                    },
                 )
-                return False
 
-    hass.data[OPNSENSE_DATA] = {
-        CONF_INTERFACE_CLIENT: client,
-        CONF_TRACKER_INTERFACES: tracker_interfaces,
-    }
+    config_entry.runtime_data = OPNsenseRuntimeData(
+        client=client,
+        tracker_interfaces=tracker_interfaces,
+    )
 
-    load_platform(hass, Platform.DEVICE_TRACKER, DOMAIN, tracker_interfaces, config)
+    await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
     return True
+
+
+async def async_unload_entry(
+    hass: HomeAssistant, config_entry: OPNsenseConfigEntry
+) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS)

homeassistant/components/opnsense/config_flow.py

@@ -0,0 +1,315 @@
+"""Config flow for OPNsense."""
+
+import logging
+from typing import Any
+
+from aiopnsense import (
+    OPNsenseBelowMinFirmware,
+    OPNsenseClient,
+    OPNsenseConnectionError,
+    OPNsenseInvalidAuth,
+    OPNsenseInvalidURL,
+    OPNsensePrivilegeMissing,
+    OPNsenseSSLError,
+    OPNsenseTimeoutError,
+    OPNsenseUnknownFirmware,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY, CONF_URL, CONF_VERIFY_SSL
+from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.issue_registry import (
+    IssueSeverity,
+    async_create_issue,
+    async_delete_issue,
+)
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
+
+from .const import CONF_API_SECRET, CONF_TRACKER_INTERFACES, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_URL): str,
+        vol.Required(CONF_API_KEY): str,
+        vol.Required(CONF_API_SECRET): str,
+        vol.Required(CONF_VERIFY_SSL, default=True): bool,
+    }
+)
+
+
+def tracker_interfaces_schema(
+    interfaces: list[str], selected: list[str] | None = None
+) -> vol.Schema:
+    """Schema to display available interfaces for device tracking selection."""
+    return vol.Schema(
+        {
+            vol.Optional(
+                CONF_TRACKER_INTERFACES,
+                default=selected or [],
+            ): SelectSelector(
+                SelectSelectorConfig(
+                    options=interfaces, mode=SelectSelectorMode.DROPDOWN, multiple=True
+                )
+            ),
+        }
+    )
+
+
+class OPNsenseConfigFlow(ConfigFlow, domain=DOMAIN):
+    """OPNsense config flow."""
+
+    def __init__(self) -> None:
+        """Initialize OPNsense config flow."""
+        self.available_interfaces: list[str] | None = None
+        self._entry_data: dict[str, Any] = {}
+
+    async def _show_setup_form(
+        self,
+        user_input: dict[Any, Any] | None = None,
+        errors: dict[Any, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Show the setup form to the user."""
+        if user_input is None:
+            user_input = {}
+
+        description_placeholders = {
+            "doc_url": "https://www.home-assistant.io/integrations/opnsense/"
+        }
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                STEP_USER_DATA_SCHEMA, user_input
+            ),
+            errors=errors or {},
+            description_placeholders=description_placeholders,
+        )
+
+    async def _show_interfaces_form(
+        self,
+        user_input: dict[Any, Any],
+        errors: dict[Any, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Show the tracker interfaces selection form to the user."""
+        return self.async_show_form(
+            step_id="interfaces",
+            data_schema=self.add_suggested_values_to_schema(
+                tracker_interfaces_schema(
+                    self.available_interfaces or [],
+                    user_input.get(CONF_TRACKER_INTERFACES),
+                ),
+                user_input,
+            ),
+            errors=errors or {},
+        )
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle user step: credentials and connection test."""
+        errors = {}
+
+        if user_input is None:
+            return await self._show_setup_form(user_input, None)
+
+        verify_ssl = user_input[CONF_VERIFY_SSL]
+        session = async_get_clientsession(self.hass, verify_ssl=verify_ssl)
+        client = OPNsenseClient(
+            user_input[CONF_URL],
+            user_input[CONF_API_KEY],
+            user_input[CONF_API_SECRET],
+            session,
+            opts={"verify_ssl": verify_ssl},
+        )
+
+        try:
+            await client.validate()
+            interfaces_resp = await client.get_interfaces()
+            known_interfaces = [
+                name
+                for ifinfo in interfaces_resp.values()
+                if (name := ifinfo.get("name"))
+            ]
+            self.available_interfaces = list(known_interfaces)
+        except OPNsenseInvalidAuth:
+            errors["base"] = "invalid_auth"
+        except OPNsensePrivilegeMissing:
+            errors["base"] = "privilege_missing"
+        except OPNsenseInvalidURL:
+            errors["base"] = "invalid_url"
+        except OPNsenseSSLError:
+            errors["base"] = "ssl_error"
+        except OPNsenseConnectionError, OPNsenseTimeoutError:
+            errors["base"] = "cannot_connect"
+        except OPNsenseUnknownFirmware:
+            errors["base"] = "unknown_version"
+        except OPNsenseBelowMinFirmware:
+            errors["base"] = "invalid_version"
+        except Exception:
+            _LOGGER.exception("Unexpected exception")
+            errors["base"] = "unknown"
+        else:
+            unique_id = await client.get_device_unique_id()
+            if not unique_id:
+                return self.async_abort(reason="no_unique_id")
+            await self.async_set_unique_id(unique_id)
+            self._abort_if_unique_id_configured()
+            self._entry_data = user_input
+            return await self.async_step_interfaces()
+
+        return await self._show_setup_form(user_input, errors)
+
+    async def async_step_interfaces(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle tracker interface selection step."""
+        if user_input is None:
+            return await self._show_interfaces_form({}, None)
+
+        if user_input.get(CONF_TRACKER_INTERFACES):
+            self._entry_data[CONF_TRACKER_INTERFACES] = user_input[
+                CONF_TRACKER_INTERFACES
+            ]
+
+        return self.async_create_entry(
+            title=self._entry_data[CONF_URL], data=self._entry_data
+        )
+
+    async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
+        """Import a Yaml config."""
+        # Test connection
+        session = async_get_clientsession(
+            self.hass, verify_ssl=import_data[CONF_VERIFY_SSL]
+        )
+        client = OPNsenseClient(
+            import_data[CONF_URL],
+            import_data[CONF_API_KEY],
+            import_data[CONF_API_SECRET],
+            session,
+            opts={"verify_ssl": import_data[CONF_VERIFY_SSL]},
+        )
+        try:
+            await client.validate()
+            interfaces_resp = await client.get_interfaces()
+        except OPNsenseInvalidURL:
+            return self._abort_import(reason="invalid_url")
+        except OPNsenseInvalidAuth:
+            return self._abort_import(reason="invalid_auth")
+        except OPNsensePrivilegeMissing:
+            return self._abort_import(reason="privilege_missing")
+        except OPNsenseSSLError:
+            return self._abort_import(reason="ssl_error")
+        except OPNsenseConnectionError, OPNsenseTimeoutError:
+            return self._abort_import(reason="cannot_connect")
+        except OPNsenseUnknownFirmware:
+            return self._abort_import(reason="unknown_version")
+        except OPNsenseBelowMinFirmware:
+            return self._abort_import(reason="invalid_version")
+        except Exception:  # Allowed in config flows
+            _LOGGER.exception("Unexpected exception during import")
+            return self._abort_import(reason="unknown")
+
+        async_create_issue(
+            self.hass,
+            HOMEASSISTANT_DOMAIN,
+            f"deprecated_yaml_{DOMAIN}",
+            breaks_in_ha_version="2026.12.0",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=IssueSeverity.WARNING,
+            translation_key="deprecated_yaml",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": "OPNsense",
+            },
+        )
+
+        unique_id = await client.get_device_unique_id()
+        if not unique_id:
+            return self._abort_import(reason="no_unique_id")
+        await self.async_set_unique_id(unique_id)
+        self._abort_if_unique_id_configured()
+
+        # Validate CONF_TRACKER_INTERFACES if present and not empty
+        verified_data = dict(import_data)
+        if CONF_TRACKER_INTERFACES in verified_data:
+            if not verified_data[CONF_TRACKER_INTERFACES]:
+                verified_data.pop(CONF_TRACKER_INTERFACES)
+            else:
+                known_interfaces = [
+                    name
+                    for ifinfo in interfaces_resp.values()
+                    if (name := ifinfo.get("name"))
+                ]
+                self.available_interfaces = sorted(known_interfaces)
+                # Abort import if any specified tracker interface is not found
+                missing = [
+                    intf_description
+                    for intf_description in verified_data[CONF_TRACKER_INTERFACES]
+                    if intf_description not in known_interfaces
+                ]
+                if missing:
+                    # Create a repair to guide the user
+                    async_create_issue(
+                        self.hass,
+                        DOMAIN,
+                        "import_failed_missing_interfaces",
+                        breaks_in_ha_version="2026.12.0",
+                        is_fixable=False,
+                        severity=IssueSeverity.ERROR,
+                        translation_key="import_failed_missing_interfaces",
+                        translation_placeholders={
+                            "missing": ", ".join(missing),
+                            "found": ", ".join(known_interfaces),
+                            "integration_title": "OPNsense",
+                        },
+                    )
+                    return self.async_abort(
+                        reason="import_failed_missing_interfaces",
+                        description_placeholders={
+                            "missing": ", ".join(missing),
+                            "found": ", ".join(known_interfaces),
+                            "integration_title": "OPNsense",
+                        },
+                    )
+
+        # Clear any previous import issues if interfaces are now valid
+        async_delete_issue(
+            self.hass,
+            DOMAIN,
+            "import_failed_missing_interfaces",
+        )
+
+        return self.async_create_entry(
+            title=verified_data[CONF_URL], data=verified_data
+        )
+
+    def _abort_import(self, reason: str) -> ConfigFlowResult:
+        """Create an issue for import errors and abort the import."""
+        async_create_issue(
+            self.hass,
+            DOMAIN,
+            f"import_failed_{reason}",
+            breaks_in_ha_version="2026.12.0",
+            is_fixable=False,
+            severity=IssueSeverity.ERROR,
+            translation_key=f"import_failed_{reason}",
+            translation_placeholders={
+                "domain": DOMAIN,
+                "integration_title": "OPNsense",
+            },
+        )
+        return self.async_abort(
+            reason=reason,
+            description_placeholders={
+                "integration_title": "OPNsense",
+            },
+        )

homeassistant/components/opnsense/const.py

@@ -1,8 +1,11 @@
 """Constants for OPNsense component."""
 
+from datetime import timedelta
+
 DOMAIN = "opnsense"
-OPNSENSE_DATA = DOMAIN
 
 CONF_API_SECRET = "api_secret"
-CONF_INTERFACE_CLIENT = "interface_client"
 CONF_TRACKER_INTERFACES = "tracker_interfaces"
+
+# Update interval for device scanning
+SCAN_INTERVAL = timedelta(seconds=30)

homeassistant/components/opnsense/coordinator.py

@@ -0,0 +1,80 @@
+"""Coordinator for OPNsense device tracker updates."""
+
+import logging
+
+from aiopnsense import (
+    OPNsenseBelowMinFirmware,
+    OPNsenseClient,
+    OPNsenseConnectionError,
+    OPNsenseInvalidAuth,
+    OPNsenseInvalidURL,
+    OPNsensePrivilegeMissing,
+    OPNsenseSSLError,
+    OPNsenseTimeoutError,
+    OPNsenseUnknownFirmware,
+)
+
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers.device_registry import format_mac
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import SCAN_INTERVAL
+from .types import DeviceDetails, DeviceDetailsByMAC, OPNsenseConfigEntry
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class OPNsenseDeviceTrackerCoordinator(DataUpdateCoordinator[DeviceDetailsByMAC]):
+    """Coordinator for OPNsense device tracker updates."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: OPNsenseConfigEntry,
+        client: OPNsenseClient,
+        interfaces: list[str],
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="OPNsense Device Tracker",
+            update_interval=SCAN_INTERVAL,
+            config_entry=config_entry,
+        )
+        self.client = client
+        self.interfaces = interfaces
+        self.tracked_devices: set[str] = set()
+
+    def _get_mac_addrs(self, devices: list[DeviceDetails]) -> DeviceDetailsByMAC:
+        """Create dict with mac address keys from list of devices."""
+        out_devices: DeviceDetailsByMAC = {}
+        for device in devices:
+            if not self.interfaces or device["intf_description"] in self.interfaces:
+                formatted_mac = format_mac(device["mac"])
+                out_devices[formatted_mac] = device
+        return out_devices
+
+    async def _async_update_data(self) -> DeviceDetailsByMAC:
+        """Fetch data from OPNsense."""
+        try:
+            devices = await self.client.get_arp_table(True)
+        except (
+            OPNsenseInvalidAuth,
+            OPNsenseInvalidURL,
+            OPNsensePrivilegeMissing,
+            OPNsenseSSLError,
+            OPNsenseBelowMinFirmware,
+            OPNsenseUnknownFirmware,
+        ) as err:
+            raise ConfigEntryError(f"Error with OPNsense configuration: {err}") from err
+        except (
+            OPNsenseConnectionError,
+            OPNsenseTimeoutError,
+        ) as err:
+            raise UpdateFailed(
+                f"Error communicating with OPNsense router: {err}"
+            ) from err
+
+        return self._get_mac_addrs(devices)

homeassistant/components/opnsense/device_tracker.py

@@ -1,71 +1,117 @@
 """Device tracker support for OPNsense routers."""
 
-from typing import Any, NewType
+from typing import Any
 
-from aiopnsense import OPNsenseClient
-
-from homeassistant.components.device_tracker import DeviceScanner
+from homeassistant.components.device_tracker import ScannerEntity
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.typing import ConfigType
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import CONF_INTERFACE_CLIENT, CONF_TRACKER_INTERFACES, OPNSENSE_DATA
-
-DeviceDetails = NewType("DeviceDetails", dict[str, Any])
-DeviceDetailsByMAC = NewType("DeviceDetailsByMAC", dict[str, DeviceDetails])
+from .coordinator import OPNsenseDeviceTrackerCoordinator
+from .types import DeviceDetails, OPNsenseConfigEntry
 
 
-async def async_get_scanner(
-    hass: HomeAssistant, config: ConfigType
-) -> DeviceScanner | None:
-    """Configure the OPNsense device_tracker."""
-    return OPNsenseDeviceScanner(
-        hass.data[OPNSENSE_DATA][CONF_INTERFACE_CLIENT],
-        hass.data[OPNSENSE_DATA][CONF_TRACKER_INTERFACES],
-    )
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: OPNsenseConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up device tracker for OPNsense component."""
+    client = entry.runtime_data.client
+    interfaces = entry.runtime_data.tracker_interfaces
+
+    coordinator = OPNsenseDeviceTrackerCoordinator(hass, entry, client, interfaces)
+
+    def _async_add_new_entities() -> None:
+        """Add entities for newly discovered devices."""
+        if not coordinator.data:
+            return
+
+        entities = []
+        for mac_address in coordinator.data:
+            if mac_address in coordinator.tracked_devices:
+                continue
+            entity = OPNsenseDeviceTrackerEntity(coordinator, mac_address)
+            coordinator.tracked_devices.add(mac_address)
+            entities.append(entity)
+
+        if entities:
+            async_add_entities(entities)
+
+    entry.async_on_unload(coordinator.async_add_listener(_async_add_new_entities))
+
+    # Initial data fetch
+    await coordinator.async_config_entry_first_refresh()
+    _async_add_new_entities()
 
 
-class OPNsenseDeviceScanner(DeviceScanner):
-    """This class queries a router running OPNsense."""
+class OPNsenseDeviceTrackerEntity(
+    CoordinatorEntity[OPNsenseDeviceTrackerCoordinator], ScannerEntity
+):
+    """Representation of a tracked device."""
 
-    def __init__(self, client: OPNsenseClient, interfaces: list[str]) -> None:
-        """Initialize the scanner."""
-        self.last_results: dict[str, Any] = {}
-        self.client = client
-        self.interfaces = interfaces
+    def __init__(
+        self,
+        coordinator: OPNsenseDeviceTrackerCoordinator,
+        mac_address: str,
+    ) -> None:
+        """Initialize the device tracker entity."""
+        super().__init__(coordinator)
+        self._attr_mac_address = mac_address
 
-    def _get_mac_addrs(self, devices: list[DeviceDetails]) -> DeviceDetailsByMAC | dict:
-        """Create dict with mac address keys from list of devices."""
-        out_devices = {}
-        for device in devices:
-            if not self.interfaces or device["intf_description"] in self.interfaces:
-                out_devices[device["mac"]] = device
-        return out_devices
+    @property
+    def device_data(self) -> DeviceDetails | None:
+        """Return device data for current device."""
+        if self.coordinator.data and self.mac_address in self.coordinator.data:
+            return self.coordinator.data[self.mac_address]
+        return None
 
-    async def async_scan_devices(self) -> list[str]:
-        """Scan for new devices and return a list with found device IDs."""
-        await self._async_update_info()
-        return list(self.last_results)
+    @property
+    def is_connected(self) -> bool:
+        """Return true if the device is connected to the network."""
+        return (
+            self.coordinator.data is not None
+            and self.mac_address in self.coordinator.data
+        )
 
-    def get_device_name(self, device: str) -> str | None:
-        """Return the name of the given device or None if we don't know."""
-        if device not in self.last_results:
-            return None
-        return self.last_results[device].get("hostname") or None
+    @property
+    def name(self) -> str:
+        """Return device name."""
+        device_data = self.device_data
+        if device_data and device_data.get("hostname"):
+            return str(device_data["hostname"])
+        return f"OPNsense {self.mac_address}"
 
-    async def _async_update_info(self) -> bool:
-        """Ensure the information from the OPNsense router is up to date.
+    @property
+    def ip_address(self) -> str | None:
+        """Return the primary IP address of the device."""
+        device_data = self.device_data
+        if device_data:
+            return device_data.get("ip")
+        return None
 
-        Return boolean if scanning successful.
-        """
-        devices = await self.client.get_arp_table(True)
-        self.last_results = self._get_mac_addrs(devices)
-        return True
+    @property
+    def hostname(self) -> str | None:
+        """Return hostname of the device."""
+        device_data = self.device_data
+        if device_data:
+            hostname = device_data.get("hostname")
+            return hostname or None
+        return None
 
-    def get_extra_attributes(self, device: str) -> dict[Any, Any]:
-        """Return the extra attrs of the given device."""
-        if device not in self.last_results:
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Return the state attributes."""
+        device_data = self.device_data
+        if not device_data:
             return {}
-        mfg = self.last_results[device].get("manufacturer")
-        if not mfg:
-            return {}
-        return {"manufacturer": mfg}
+
+        attrs = {}
+        if manufacturer := device_data.get("manufacturer"):
+            attrs["manufacturer"] = manufacturer
+        if interface := device_data.get("intf_description"):
+            attrs["interface"] = interface
+        if expires := device_data.get("expires"):
+            attrs["expires"] = expires
+
+        return attrs

homeassistant/components/opnsense/manifest.json

@@ -2,6 +2,7 @@
   "domain": "opnsense",
   "name": "OPNsense",
   "codeowners": ["@HarlemSquirrel", "@Snuffy2"],
+  "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/opnsense",
   "integration_type": "hub",
   "iot_class": "local_polling",

homeassistant/components/opnsense/strings.json

@@ -0,0 +1,117 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "import_failed_missing_interfaces": "The following OPNsense tracker interfaces were not found: {missing}. Found interfaces were: {found}. Please manually set up a config entry and remove the YAML config",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_url": "URL is invalid or unreachable",
+      "invalid_version": "Unsupported OPNsense firmware version",
+      "no_unique_id": "Could not determine a unique identifier for this OPNsense router. Please ensure the API key has sufficient privileges, and your OPNsense instance has physical ports with a MAC address.",
+      "privilege_missing": "The API key used does not have sufficient privileges. Please check the integration documentation for required permissions",
+      "ssl_error": "SSL certificate verification failed",
+      "unknown": "[%key:common::config_flow::error::unknown%]",
+      "unknown_version": "The OPNsense firmware version is unknown. Please ensure you are running a supported version of OPNsense and the user has the correct permissions."
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_interface": "Interface(s) do not exist",
+      "invalid_url": "URL is invalid or unreachable",
+      "invalid_version": "Unsupported OPNsense firmware version",
+      "privilege_missing": "[%key:component::opnsense::config::abort::privilege_missing%]",
+      "ssl_error": "SSL certificate verification failed",
+      "unknown": "[%key:common::config_flow::error::unknown%]",
+      "unknown_version": "The OPNsense firmware version is unknown. Please ensure you are running a supported version of OPNsense and the user has the correct permissions."
+    },
+    "step": {
+      "interfaces": {
+        "data": {
+          "tracker_interfaces": "Interface(s) to use for tracking devices"
+        },
+        "description": "Select the OPNsense interfaces to use for tracking devices. If no interfaces are selected then all interfaces will be used for tracking."
+      },
+      "user": {
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]",
+          "api_secret": "API secret",
+          "url": "[%key:common::config_flow::data::url%]",
+          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+        },
+        "description": "Set required parameters to connect to your router. For more information, please refer to the [integration documentation]({doc_url})"
+      }
+    }
+  },
+  "exceptions": {
+    "cannot_connect": {
+      "message": "Connection failure while connecting to OPNsense API endpoint at {url}"
+    },
+    "firmware_too_old": {
+      "message": "OPNsense firmware at {url} is below the minimum supported version"
+    },
+    "invalid_auth": {
+      "message": "Authentication failure while connecting to OPNsense API endpoint at {url}"
+    },
+    "invalid_url": {
+      "message": "Invalid URL while connecting to OPNsense API endpoint at {url}"
+    },
+    "privilege_missing": {
+      "message": "The API user connecting to {url} does not have sufficient privileges"
+    },
+    "ssl_error": {
+      "message": "Unable to verify SSL certificate while connecting to OPNsense API endpoint at {url}"
+    },
+    "timeout_connecting": {
+      "message": "Timeout while connecting to OPNsense API endpoint at {url}"
+    },
+    "tracker_interface_not_found": {
+      "message": "Configured tracker interface {interface} is not present on the OPNsense router. Known interfaces: {known}"
+    },
+    "unknown_firmware": {
+      "message": "Could not determine the OPNsense firmware version at {url}"
+    }
+  },
+  "issues": {
+    "import_failed_cannot_connect": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, a connection error occurred. Please correct your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_invalid_auth": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, an authentication error occurred. Please correct your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_invalid_url": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, an error occurred indicating the URL provided is invalid or unreachable. Please correct your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_invalid_version": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, an error occurred indicating the OPNsense firmware version is unsupported. Please correct your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_missing_interfaces": {
+      "description": "The following OPNsense tracker interfaces were not found: {missing}. Found interfaces were: {found}. Please manually set up a config entry and remove the YAML config",
+      "title": "The {integration_title} YAML import failed: Missing tracker interfaces"
+    },
+    "import_failed_no_unique_id": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, a unique identifier for the router could not be determined. Please ensure the API key has sufficient privileges, and your OPNsense instance has physical ports with a MAC address.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_privilege_missing": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, an error occurred indicating the API key used does not have sufficient privileges. Please check the integration documentation for required permissions, correct your YAML configuration, and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_ssl_error": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, an SSL error occurred. Please correct your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_unknown": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, an unknown error occurred. Please correct your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    },
+    "import_failed_unknown_version": {
+      "description": "Configuring {integration_title} via YAML is deprecated and will be removed in a future release. While importing your configuration, an error occurred indicating the OPNsense firmware version is unknown. Please correct your YAML configuration and restart Home Assistant, or remove the {domain} key from your configuration and configure the integration via the UI.",
+      "title": "The {integration_title} YAML configuration is being removed"
+    }
+  }
+}

homeassistant/components/opnsense/types.py

@@ -0,0 +1,21 @@
+"""Types for OPNsense routers."""
+
+from dataclasses import dataclass
+from typing import Any
+
+from aiopnsense import OPNsenseClient
+
+from homeassistant.config_entries import ConfigEntry
+
+
+@dataclass(slots=True)
+class OPNsenseRuntimeData:
+    """Runtime data for OPNsense config entries."""
+
+    client: OPNsenseClient
+    tracker_interfaces: list[str]
+
+
+type DeviceDetails = dict[str, Any]
+type DeviceDetailsByMAC = dict[str, DeviceDetails]
+type OPNsenseConfigEntry = ConfigEntry[OPNsenseRuntimeData]

homeassistant/components/opower/coordinator.py

@@ -111,8 +111,11 @@ class OpowerCoordinator(DataUpdateCoordinator[dict[str, OpowerData]]):
             raise ConfigEntryAuthFailed from err
         except CannotConnect as err:
             _LOGGER.error("Error during login: %s", err)
-            # pylint: disable-next=home-assistant-exception-not-translated
-            raise UpdateFailed(f"Error during login: {err}") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="login_error",
+                translation_placeholders={"error": str(err)},
+            ) from err
 
         try:
             accounts = await self.api.async_get_accounts()