Merge branch 'dev' into window_covering_calibrate

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>

.github/workflows/builder.yml

@@ -10,12 +10,12 @@ on:
 
 env:
   BUILD_TYPE: core
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.14.2"
   PIP_TIMEOUT: 60
   UV_HTTP_TIMEOUT: 60
   UV_SYSTEM_PYTHON: "true"
   # Base image version from https://github.com/home-assistant/docker
-  BASE_IMAGE_VERSION: "2025.12.0"
+  BASE_IMAGE_VERSION: "2026.01.0"
   ARCHITECTURES: '["amd64", "aarch64"]'
 
 jobs:
@@ -184,7 +184,7 @@ jobs:
           echo "${{ github.sha }};${{ github.ref }};${{ github.event_name }};${{ github.actor }}" > rootfs/OFFICIAL_IMAGE
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -287,7 +287,7 @@ jobs:
           fi
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -358,13 +358,13 @@ jobs:
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -522,7 +522,7 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}

.github/workflows/ci.yaml

@@ -40,9 +40,9 @@ env:
   CACHE_VERSION: 2
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.2"
-  DEFAULT_PYTHON: "3.13.11"
-  ALL_PYTHON_VERSIONS: "['3.13.11', '3.14.2']"
+  HA_SHORT_VERSION: "2026.3"
+  DEFAULT_PYTHON: "3.14.2"
+  ALL_PYTHON_VERSIONS: "['3.14.2']"
   # 10.3 is the oldest supported version
   # - 10.3.32 is the version currently shipped with Synology (as of 17 Feb 2022)
   # 10.6 is the current long-term-support
@@ -310,7 +310,7 @@ jobs:
             env.HA_SHORT_VERSION }}-$(date -u '+%Y-%m-%dT%H:%M:%s')" >> $GITHUB_OUTPUT
       - name: Restore base Python virtual environment
         id: cache-venv
-        uses: &actions-cache actions/cache@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: &actions-cache actions/cache@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
         with:
           path: venv
           key: &key-python-venv >-
@@ -374,7 +374,7 @@ jobs:
           fi
       - name: Save apt cache
         if: steps.cache-apt-check.outputs.cache-hit != 'true'
-        uses: &actions-cache-save actions/cache/save@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: &actions-cache-save actions/cache/save@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
         with:
           path: *path-apt-cache
           key: *key-apt-cache
@@ -425,7 +425,7 @@ jobs:
     steps:
       - &cache-restore-apt
         name: Restore apt cache
-        uses: &actions-cache-restore actions/cache/restore@8b402f58fbc84540c8b491a91e594a4576fec3d7 # v5.0.2
+        uses: &actions-cache-restore actions/cache/restore@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
         with:
           path: *path-apt-cache
           fail-on-cache-miss: true

.github/workflows/translations.yml

@@ -10,7 +10,7 @@ on:
       - "**strings.json"
 
 env:
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.14.2"
 
 jobs:
   upload:

.github/workflows/wheels.yml

@@ -17,7 +17,7 @@ on:
       - "script/gen_requirements_all.py"
 
 env:
-  DEFAULT_PYTHON: "3.13"
+  DEFAULT_PYTHON: "3.14.2"
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref_name}}

.python-version

@@ -1 +1 @@
-3.13
+3.14

CODEOWNERS

@@ -921,6 +921,8 @@ build.json @home-assistant/supervisor
 /tests/components/libre_hardware_monitor/ @Sab44
 /homeassistant/components/lidarr/ @tkdrob
 /tests/components/lidarr/ @tkdrob
+/homeassistant/components/liebherr/ @mettolen
+/tests/components/liebherr/ @mettolen
 /homeassistant/components/lifx/ @Djelibeybi
 /tests/components/lifx/ @Djelibeybi
 /homeassistant/components/light/ @home-assistant/core
@@ -1878,6 +1880,8 @@ build.json @home-assistant/supervisor
 /tests/components/worldclock/ @fabaff
 /homeassistant/components/ws66i/ @ssaenger
 /tests/components/ws66i/ @ssaenger
+/homeassistant/components/wsdot/ @ucodery
+/tests/components/wsdot/ @ucodery
 /homeassistant/components/wyoming/ @synesthesiam
 /tests/components/wyoming/ @synesthesiam
 /homeassistant/components/xbox/ @hunterjm @tr4nt0r

Dockerfile.dev

@@ -52,6 +52,9 @@ RUN --mount=type=bind,source=requirements.txt,target=requirements.txt \
     --mount=type=bind,source=requirements_test_pre_commit.txt,target=requirements_test_pre_commit.txt \
     uv pip install -r requirements.txt -r requirements_test.txt
 
+# Claude Code native install
+RUN curl -fsSL https://claude.ai/install.sh | bash
+
 WORKDIR /workspaces
 
 # Set the default shell to bash instead of sh

homeassistant/brands/heatit.json

@@ -1,5 +0,0 @@
-{
-  "domain": "heatit",
-  "name": "Heatit",
-  "iot_standards": ["zwave"]
-}

homeassistant/brands/heiman.json

@@ -1,5 +0,0 @@
-{
-  "domain": "heiman",
-  "name": "Heiman",
-  "iot_standards": ["matter", "zigbee"]
-}

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==11.1.1"]
+  "requirements": ["aioamazondevices==11.0.2"]
 }

homeassistant/components/alexa_devices/sensor.py

@@ -28,7 +28,6 @@ from homeassistant.helpers.typing import StateType
 from .const import CATEGORY_NOTIFICATIONS, CATEGORY_SENSORS
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
-from .utils import async_remove_unsupported_notification_sensors
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -106,9 +105,6 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    # Remove notification sensors from unsupported devices
-    await async_remove_unsupported_notification_sensors(hass, coordinator)
-
     known_devices: set[str] = set()
 
     def _check_device() -> None:
@@ -126,7 +122,6 @@ async def async_setup_entry(
                 AmazonSensorEntity(coordinator, serial_num, notification_desc)
                 for notification_desc in NOTIFICATIONS
                 for serial_num in new_devices
-                if coordinator.data[serial_num].notifications_supported
             ]
             async_add_entities(sensors_list + notifications_list)
 

homeassistant/components/alexa_devices/utils.py

@@ -5,14 +5,8 @@ from functools import wraps
 from typing import Any, Concatenate
 
 from aioamazondevices.const.devices import SPEAKER_GROUP_FAMILY
-from aioamazondevices.const.schedules import (
-    NOTIFICATION_ALARM,
-    NOTIFICATION_REMINDER,
-    NOTIFICATION_TIMER,
-)
 from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData
 
-from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
@@ -87,27 +81,3 @@ async def async_remove_dnd_from_virtual_group(
         if entity_id and is_group:
             entity_registry.async_remove(entity_id)
             _LOGGER.debug("Removed DND switch from virtual group %s", entity_id)
-
-
-async def async_remove_unsupported_notification_sensors(
-    hass: HomeAssistant,
-    coordinator: AmazonDevicesCoordinator,
-) -> None:
-    """Remove notification sensors from unsupported devices."""
-    entity_registry = er.async_get(hass)
-
-    for serial_num in coordinator.data:
-        for notification_key in (
-            NOTIFICATION_ALARM,
-            NOTIFICATION_REMINDER,
-            NOTIFICATION_TIMER,
-        ):
-            unique_id = f"{serial_num}-{notification_key}"
-            entity_id = entity_registry.async_get_entity_id(
-                domain=SENSOR_DOMAIN, platform=DOMAIN, unique_id=unique_id
-            )
-            is_unsupported = not coordinator.data[serial_num].notifications_supported
-
-            if entity_id and is_unsupported:
-                entity_registry.async_remove(entity_id)
-                _LOGGER.debug("Removed unsupported notification sensor %s", entity_id)

homeassistant/components/analytics/manifest.json

@@ -10,7 +10,6 @@
   "preview_features": {
     "snapshots": {
       "feedback_url": "https://forms.gle/GqvRmgmghSDco8M46",
-      "learn_more_url": "https://www.home-assistant.io/blog/2026/02/02/about-device-database/",
       "report_issue_url": "https://github.com/OHF-Device-Database/device-database/issues/new"
     }
   },

homeassistant/components/analytics/strings.json

@@ -1,7 +1,7 @@
 {
   "preview_features": {
     "snapshots": {
-      "description": "We're creating the [Open Home Foundation Device Database](https://www.home-assistant.io/blog/2026/02/02/about-device-database/): a free, open source community-powered resource to help users find practical information about how smart home devices perform in real installations.\n\nYou can help us build it by opting in to share anonymized data about your devices. This data will only ever include device-specific details (like model or manufacturer) – never personally identifying information (like the names you assign).\n\nFind out how we process your data (should you choose to contribute) in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement).",
+      "description": "This free, open source device database of the Open Home Foundation helps users find useful information about smart home devices used in real installations.\n\nYou can help build it by anonymously sharing data about your devices. Only device-specific details (like model or manufacturer) are shared — never personally identifying information (like the names you assign).\n\nLearn more about the device database and how we process your data in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement), which you accept by opting in.",
       "disable_confirmation": "Your data will no longer be shared with the Open Home Foundation's device database.",
       "enable_confirmation": "This feature is still in development and may change. The device database is being refined based on user feedback and is not yet complete.",
       "name": "Device database"

homeassistant/components/anthropic/__init__.py

@@ -14,18 +14,10 @@ from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     entity_registry as er,
-    issue_registry as ir,
 )
 from homeassistant.helpers.typing import ConfigType
 
-from .const import (
-    CONF_CHAT_MODEL,
-    DATA_REPAIR_DEFER_RELOAD,
-    DEFAULT_CONVERSATION_NAME,
-    DEPRECATED_MODELS,
-    DOMAIN,
-    LOGGER,
-)
+from .const import DEFAULT_CONVERSATION_NAME, DOMAIN, LOGGER
 
 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -35,7 +27,6 @@ type AnthropicConfigEntry = ConfigEntry[anthropic.AsyncClient]
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Anthropic."""
-    hass.data.setdefault(DOMAIN, {}).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
     await async_migrate_integration(hass)
     return True
 
@@ -59,22 +50,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) ->
 
     entry.async_on_unload(entry.add_update_listener(async_update_options))
 
-    for subentry in entry.subentries.values():
-        if (model := subentry.data.get(CONF_CHAT_MODEL)) and model.startswith(
-            tuple(DEPRECATED_MODELS)
-        ):
-            ir.async_create_issue(
-                hass,
-                DOMAIN,
-                "model_deprecated",
-                is_fixable=True,
-                is_persistent=False,
-                learn_more_url="https://platform.claude.com/docs/en/about-claude/model-deprecations",
-                severity=ir.IssueSeverity.WARNING,
-                translation_key="model_deprecated",
-            )
-            break
-
     return True
 
 
@@ -87,11 +62,6 @@ async def async_update_options(
     hass: HomeAssistant, entry: AnthropicConfigEntry
 ) -> None:
     """Update options."""
-    defer_reload_entries: set[str] = hass.data.setdefault(DOMAIN, {}).setdefault(
-        DATA_REPAIR_DEFER_RELOAD, set()
-    )
-    if entry.entry_id in defer_reload_entries:
-        return
     await hass.config_entries.async_reload(entry.entry_id)
 
 

homeassistant/components/anthropic/config_flow.py

@@ -92,40 +92,6 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
     await client.models.list(timeout=10.0)
 
 
-async def get_model_list(client: anthropic.AsyncAnthropic) -> list[SelectOptionDict]:
-    """Get list of available models."""
-    try:
-        models = (await client.models.list()).data
-    except anthropic.AnthropicError:
-        models = []
-    _LOGGER.debug("Available models: %s", models)
-    model_options: list[SelectOptionDict] = []
-    short_form = re.compile(r"[^\d]-\d$")
-    for model_info in models:
-        # Resolve alias from versioned model name:
-        model_alias = (
-            model_info.id[:-9]
-            if model_info.id
-            not in (
-                "claude-3-haiku-20240307",
-                "claude-3-5-haiku-20241022",
-                "claude-3-opus-20240229",
-            )
-            else model_info.id
-        )
-        if short_form.search(model_alias):
-            model_alias += "-0"
-        if model_alias.endswith(("haiku", "opus", "sonnet")):
-            model_alias += "-latest"
-        model_options.append(
-            SelectOptionDict(
-                label=model_info.display_name,
-                value=model_alias,
-            )
-        )
-    return model_options
-
-
 class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anthropic."""
 
@@ -435,13 +401,38 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
 
     async def _get_model_list(self) -> list[SelectOptionDict]:
         """Get list of available models."""
-        client = await self.hass.async_add_executor_job(
-            partial(
-                anthropic.AsyncAnthropic,
-                api_key=self._get_entry().data[CONF_API_KEY],
+        try:
+            client = await self.hass.async_add_executor_job(
+                partial(
+                    anthropic.AsyncAnthropic,
+                    api_key=self._get_entry().data[CONF_API_KEY],
+                )
             )
-        )
-        return await get_model_list(client)
+            models = (await client.models.list()).data
+        except anthropic.AnthropicError:
+            models = []
+        _LOGGER.debug("Available models: %s", models)
+        model_options: list[SelectOptionDict] = []
+        short_form = re.compile(r"[^\d]-\d$")
+        for model_info in models:
+            # Resolve alias from versioned model name:
+            model_alias = (
+                model_info.id[:-9]
+                if model_info.id
+                not in ("claude-3-haiku-20240307", "claude-3-opus-20240229")
+                else model_info.id
+            )
+            if short_form.search(model_alias):
+                model_alias += "-0"
+            if model_alias.endswith(("haiku", "opus", "sonnet")):
+                model_alias += "-latest"
+            model_options.append(
+                SelectOptionDict(
+                    label=model_info.display_name,
+                    value=model_alias,
+                )
+            )
+        return model_options
 
     async def _get_location_data(self) -> dict[str, str]:
         """Get approximate location data of the user."""

homeassistant/components/anthropic/const.py

@@ -22,10 +22,8 @@ CONF_WEB_SEARCH_REGION = "region"
 CONF_WEB_SEARCH_COUNTRY = "country"
 CONF_WEB_SEARCH_TIMEZONE = "timezone"
 
-DATA_REPAIR_DEFER_RELOAD = "repair_defer_reload"
-
 DEFAULT = {
-    CONF_CHAT_MODEL: "claude-haiku-4-5",
+    CONF_CHAT_MODEL: "claude-3-5-haiku-latest",
     CONF_MAX_TOKENS: 3000,
     CONF_TEMPERATURE: 1.0,
     CONF_THINKING_BUDGET: 0,
@@ -48,10 +46,3 @@ WEB_SEARCH_UNSUPPORTED_MODELS = [
     "claude-3-5-sonnet-20240620",
     "claude-3-5-sonnet-20241022",
 ]
-
-DEPRECATED_MODELS = [
-    "claude-3-5-haiku",
-    "claude-3-7-sonnet",
-    "claude-3-5-sonnet",
-    "claude-3-opus",
-]

homeassistant/components/anthropic/repairs.py

@@ -1,275 +0,0 @@
-"""Issue repair flow for Anthropic."""
-
-from __future__ import annotations
-
-from collections.abc import Iterator
-from typing import cast
-
-import voluptuous as vol
-
-from homeassistant import data_entry_flow
-from homeassistant.components.repairs import RepairsFlow
-from homeassistant.config_entries import ConfigEntry, ConfigEntryState, ConfigSubentry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.selector import SelectSelector, SelectSelectorConfig
-
-from .config_flow import get_model_list
-from .const import (
-    CONF_CHAT_MODEL,
-    DATA_REPAIR_DEFER_RELOAD,
-    DEFAULT,
-    DEPRECATED_MODELS,
-    DOMAIN,
-)
-
-
-class ModelDeprecatedRepairFlow(RepairsFlow):
-    """Handler for an issue fixing flow."""
-
-    _subentry_iter: Iterator[tuple[str, str]] | None
-    _current_entry_id: str | None
-    _current_subentry_id: str | None
-    _reload_pending: set[str]
-    _pending_updates: dict[str, dict[str, str]]
-
-    def __init__(self) -> None:
-        """Initialize the flow."""
-        super().__init__()
-        self._subentry_iter = None
-        self._current_entry_id = None
-        self._current_subentry_id = None
-        self._reload_pending = set()
-        self._pending_updates = {}
-
-    async def async_step_init(
-        self, user_input: dict[str, str] | None = None
-    ) -> data_entry_flow.FlowResult:
-        """Handle the first step of a fix flow."""
-        previous_entry_id: str | None = None
-        if user_input is not None:
-            previous_entry_id = self._async_update_current_subentry(user_input)
-            self._clear_current_target()
-
-        target = await self._async_next_target()
-        next_entry_id = target[0].entry_id if target else None
-        if previous_entry_id and previous_entry_id != next_entry_id:
-            await self._async_apply_pending_updates(previous_entry_id)
-        if target is None:
-            await self._async_apply_all_pending_updates()
-            return self.async_create_entry(data={})
-
-        entry, subentry, model = target
-        client = entry.runtime_data
-        model_list = [
-            model_option
-            for model_option in await get_model_list(client)
-            if not model_option["value"].startswith(tuple(DEPRECATED_MODELS))
-        ]
-
-        if "opus" in model:
-            suggested_model = "claude-opus-4-5"
-        elif "haiku" in model:
-            suggested_model = "claude-haiku-4-5"
-        elif "sonnet" in model:
-            suggested_model = "claude-sonnet-4-5"
-        else:
-            suggested_model = cast(str, DEFAULT[CONF_CHAT_MODEL])
-
-        schema = vol.Schema(
-            {
-                vol.Required(
-                    CONF_CHAT_MODEL,
-                    default=suggested_model,
-                ): SelectSelector(
-                    SelectSelectorConfig(options=model_list, custom_value=True)
-                ),
-            }
-        )
-
-        return self.async_show_form(
-            step_id="init",
-            data_schema=schema,
-            description_placeholders={
-                "entry_name": entry.title,
-                "model": model,
-                "subentry_name": subentry.title,
-                "subentry_type": self._format_subentry_type(subentry.subentry_type),
-            },
-        )
-
-    def _iter_deprecated_subentries(self) -> Iterator[tuple[str, str]]:
-        """Yield entry/subentry pairs that use deprecated models."""
-        for entry in self.hass.config_entries.async_entries(DOMAIN):
-            if entry.state is not ConfigEntryState.LOADED:
-                continue
-            for subentry in entry.subentries.values():
-                model = subentry.data.get(CONF_CHAT_MODEL)
-                if model and model.startswith(tuple(DEPRECATED_MODELS)):
-                    yield entry.entry_id, subentry.subentry_id
-
-    async def _async_next_target(
-        self,
-    ) -> tuple[ConfigEntry, ConfigSubentry, str] | None:
-        """Return the next deprecated subentry target."""
-        if self._subentry_iter is None:
-            self._subentry_iter = self._iter_deprecated_subentries()
-
-        while True:
-            try:
-                entry_id, subentry_id = next(self._subentry_iter)
-            except StopIteration:
-                return None
-
-            entry = self.hass.config_entries.async_get_entry(entry_id)
-            if entry is None:
-                continue
-
-            subentry = entry.subentries.get(subentry_id)
-            if subentry is None:
-                continue
-
-            model = self._pending_model(entry_id, subentry_id)
-            if model is None:
-                model = subentry.data.get(CONF_CHAT_MODEL)
-            if not model or not model.startswith(tuple(DEPRECATED_MODELS)):
-                continue
-
-            self._current_entry_id = entry_id
-            self._current_subentry_id = subentry_id
-            return entry, subentry, model
-
-    def _async_update_current_subentry(self, user_input: dict[str, str]) -> str | None:
-        """Update the currently selected subentry."""
-        if not self._current_entry_id or not self._current_subentry_id:
-            return None
-
-        entry = self.hass.config_entries.async_get_entry(self._current_entry_id)
-        if entry is None:
-            return None
-
-        subentry = entry.subentries.get(self._current_subentry_id)
-        if subentry is None:
-            return None
-
-        updated_data = {
-            **subentry.data,
-            CONF_CHAT_MODEL: user_input[CONF_CHAT_MODEL],
-        }
-        if updated_data == subentry.data:
-            return entry.entry_id
-        self._queue_pending_update(
-            entry.entry_id,
-            subentry.subentry_id,
-            updated_data[CONF_CHAT_MODEL],
-        )
-        return entry.entry_id
-
-    def _clear_current_target(self) -> None:
-        """Clear current target tracking."""
-        self._current_entry_id = None
-        self._current_subentry_id = None
-
-    def _format_subentry_type(self, subentry_type: str) -> str:
-        """Return a user-friendly subentry type label."""
-        if subentry_type == "conversation":
-            return "Conversation agent"
-        if subentry_type in ("ai_task", "ai_task_data"):
-            return "AI task"
-        return subentry_type
-
-    def _queue_pending_update(
-        self, entry_id: str, subentry_id: str, model: str
-    ) -> None:
-        """Store a pending model update for a subentry."""
-        self._pending_updates.setdefault(entry_id, {})[subentry_id] = model
-
-    def _pending_model(self, entry_id: str, subentry_id: str) -> str | None:
-        """Return a pending model update if one exists."""
-        return self._pending_updates.get(entry_id, {}).get(subentry_id)
-
-    def _mark_entry_for_reload(self, entry_id: str) -> None:
-        """Prevent reload until repairs are complete for the entry."""
-        self._reload_pending.add(entry_id)
-        defer_reload_entries: set[str] = self.hass.data.setdefault(
-            DOMAIN, {}
-        ).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
-        defer_reload_entries.add(entry_id)
-
-    async def _async_reload_entry(self, entry_id: str) -> None:
-        """Reload an entry once all repairs are completed."""
-        if entry_id not in self._reload_pending:
-            return
-
-        entry = self.hass.config_entries.async_get_entry(entry_id)
-        if entry is not None and entry.state is not ConfigEntryState.LOADED:
-            self._clear_defer_reload(entry_id)
-            self._reload_pending.discard(entry_id)
-            return
-
-        if entry is not None:
-            await self.hass.config_entries.async_reload(entry_id)
-
-        self._clear_defer_reload(entry_id)
-        self._reload_pending.discard(entry_id)
-
-    def _clear_defer_reload(self, entry_id: str) -> None:
-        """Remove entry from the deferred reload set."""
-        defer_reload_entries: set[str] = self.hass.data.setdefault(
-            DOMAIN, {}
-        ).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
-        defer_reload_entries.discard(entry_id)
-
-    async def _async_apply_pending_updates(self, entry_id: str) -> None:
-        """Apply pending subentry updates for a single entry."""
-        updates = self._pending_updates.pop(entry_id, None)
-        if not updates:
-            return
-
-        entry = self.hass.config_entries.async_get_entry(entry_id)
-        if entry is None or entry.state is not ConfigEntryState.LOADED:
-            return
-
-        changed = False
-        for subentry_id, model in updates.items():
-            subentry = entry.subentries.get(subentry_id)
-            if subentry is None:
-                continue
-
-            updated_data = {
-                **subentry.data,
-                CONF_CHAT_MODEL: model,
-            }
-            if updated_data == subentry.data:
-                continue
-
-            if not changed:
-                self._mark_entry_for_reload(entry_id)
-                changed = True
-
-            self.hass.config_entries.async_update_subentry(
-                entry,
-                subentry,
-                data=updated_data,
-            )
-
-        if not changed:
-            return
-
-        await self._async_reload_entry(entry_id)
-
-    async def _async_apply_all_pending_updates(self) -> None:
-        """Apply all pending updates across entries."""
-        for entry_id in list(self._pending_updates):
-            await self._async_apply_pending_updates(entry_id)
-
-
-async def async_create_fix_flow(
-    hass: HomeAssistant,
-    issue_id: str,
-    data: dict[str, str | int | float | None] | None,
-) -> RepairsFlow:
-    """Create flow."""
-    if issue_id == "model_deprecated":
-        return ModelDeprecatedRepairFlow()
-    raise HomeAssistantError("Unknown issue ID")

homeassistant/components/anthropic/strings.json

@@ -109,21 +109,5 @@
         }
       }
     }
-  },
-  "issues": {
-    "model_deprecated": {
-      "fix_flow": {
-        "step": {
-          "init": {
-            "data": {
-              "chat_model": "[%key:common::generic::model%]"
-            },
-            "description": "You are updating {subentry_name} ({subentry_type}) in {entry_name}. The current model {model} is deprecated. Select a supported model to continue.",
-            "title": "Update model"
-          }
-        }
-      },
-      "title": "Model deprecated"
-    }
   }
 }

homeassistant/components/apcupsd/sensor.py

@@ -540,17 +540,7 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
         data = self.coordinator.data[key]
 
         if self.entity_description.device_class == SensorDeviceClass.TIMESTAMP:
-            # The date could be "N/A" for certain fields (e.g., XOFFBATT), indicating there is no value yet.
-            if data == "N/A":
-                self._attr_native_value = None
-                return
-
-            try:
-                self._attr_native_value = dateutil.parser.parse(data)
-            except (dateutil.parser.ParserError, OverflowError):
-                # If parsing fails we should mark it as unknown, with a log for further debugging.
-                _LOGGER.warning('Failed to parse date for %s: "%s"', key, data)
-                self._attr_native_value = None
+            self._attr_native_value = dateutil.parser.parse(data)
             return
 
         self._attr_native_value, inferred_unit = infer_unit(data)

homeassistant/components/axis/config_flow.py

@@ -52,7 +52,7 @@ from .const import (
 from .errors import AuthenticationRequired, CannotConnect
 from .hub import AxisHub, get_axis_api
 
-AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f", "e8:27:25"}
+AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f"}
 DEFAULT_PORT = 443
 DEFAULT_PROTOCOL = "https"
 PROTOCOL_CHOICES = ["https", "http"]

homeassistant/components/bang_olufsen/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/bang_olufsen",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["mozart-api==5.3.1.108.0"],
+  "requirements": ["mozart-api==5.3.1.108.2"],
   "zeroconf": ["_bangolufsen._tcp.local."]
 }

homeassistant/components/bang_olufsen/media_player.py

@@ -8,6 +8,7 @@ from datetime import timedelta
 import json
 import logging
 from typing import TYPE_CHECKING, Any, cast
+from uuid import UUID
 
 from aiohttp import ClientConnectorError
 from mozart_api import __version__ as MOZART_API_VERSION
@@ -735,7 +736,7 @@ class BeoMediaPlayer(BeoEntity, MediaPlayerEntity):
             await self._client.set_active_source(source_id=key)
         else:
             # Video
-            await self._client.post_remote_trigger(id=key)
+            await self._client.post_remote_trigger(id=UUID(key))
 
     async def async_select_sound_mode(self, sound_mode: str) -> None:
         """Select a sound mode."""
@@ -894,7 +895,7 @@ class BeoMediaPlayer(BeoEntity, MediaPlayerEntity):
                     translation_key="play_media_error",
                     translation_placeholders={
                         "media_type": media_type,
-                        "error_message": json.loads(error.body)["message"],
+                        "error_message": json.loads(cast(str, error.body))["message"],
                     },
                 ) from error
 

homeassistant/components/camera/strings.json

@@ -50,11 +50,11 @@
   "selector": {},
   "services": {
     "disable_motion_detection": {
-      "description": "Disables the motion detection.",
+      "description": "Disables the motion detection of a camera.",
       "name": "Disable motion detection"
     },
     "enable_motion_detection": {
-      "description": "Enables the motion detection.",
+      "description": "Enables the motion detection of a camera.",
       "name": "Enable motion detection"
     },
     "play_stream": {
@@ -100,11 +100,11 @@
       "name": "Take snapshot"
     },
     "turn_off": {
-      "description": "Turns off the camera.",
+      "description": "Turns off a camera.",
       "name": "[%key:common::action::turn_off%]"
     },
     "turn_on": {
-      "description": "Turns on the camera.",
+      "description": "Turns on a camera.",
       "name": "[%key:common::action::turn_on%]"
     }
   },

homeassistant/components/cloud/entity.py

@@ -459,17 +459,8 @@ class BaseCloudLLMEntity(Entity):
         last_content: Any = chat_log.content[-1]
         if last_content.role == "user" and last_content.attachments:
             files = await self._async_prepare_files_for_prompt(last_content.attachments)
-
-            last_message = cast(dict[str, Any], messages[-1])
-            assert (
-                last_message["type"] == "message"
-                and last_message["role"] == "user"
-                and isinstance(last_message["content"], str)
-            )
-            last_message["content"] = [
-                {"type": "input_text", "text": last_message["content"]},
-                *files,
-            ]
+            current_content = last_content.content
+            last_content = [*(current_content or []), *files]
 
         tools: list[ToolParam] = []
         tool_choice: str | None = None

homeassistant/components/compit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["compit"],
   "quality_scale": "bronze",
-  "requirements": ["compit-inext-api==0.8.0"]
+  "requirements": ["compit-inext-api==0.6.0"]
 }

homeassistant/components/conversation/__init__.py

@@ -335,20 +335,18 @@ def _get_config_intents(config: ConfigType, hass_config_path: str) -> dict[str,
     """Return config intents."""
     intents = config.get(DOMAIN, {}).get("intents", {})
     return {
-        "intents": {
-            intent_name: {
-                "data": [
-                    {
-                        "sentences": sentences,
-                        "metadata": {
-                            METADATA_CUSTOM_SENTENCE: True,
-                            METADATA_CUSTOM_FILE: hass_config_path,
-                        },
-                    }
-                ]
-            }
-            for intent_name, sentences in intents.items()
+        intent_name: {
+            "data": [
+                {
+                    "sentences": sentences,
+                    "metadata": {
+                        METADATA_CUSTOM_SENTENCE: True,
+                        METADATA_CUSTOM_FILE: hass_config_path,
+                    },
+                }
+            ]
         }
+        for intent_name, sentences in intents.items()
     }
 
 

homeassistant/components/conversation/agent_manager.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 import dataclasses
 import logging
 from typing import TYPE_CHECKING, Any
@@ -18,7 +19,7 @@ from homeassistant.core import (
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, intent, singleton
 
-from .const import DATA_COMPONENT, HOME_ASSISTANT_AGENT
+from .const import DATA_COMPONENT, HOME_ASSISTANT_AGENT, IntentSource
 from .entity import ConversationEntity
 from .models import (
     AbstractConversationAgent,
@@ -34,9 +35,11 @@ from .trace import (
 
 _LOGGER = logging.getLogger(__name__)
 
+TRIGGER_INTENT_NAME_PREFIX = "HassSentenceTrigger"
+
 if TYPE_CHECKING:
     from .default_agent import DefaultAgent
-    from .trigger import TriggerDetails
+    from .trigger import TRIGGER_CALLBACK_TYPE
 
 
 @singleton.singleton("conversation_agent")
@@ -139,6 +142,10 @@ async def async_converse(
         return result
 
 
+type IntentSourceConfig = dict[str, dict[str, Any]]
+type IntentsCallback = Callable[[dict[IntentSource, IntentSourceConfig]], None]
+
+
 class AgentManager:
     """Class to manage conversation agents."""
 
@@ -147,8 +154,13 @@ class AgentManager:
         self.hass = hass
         self._agents: dict[str, AbstractConversationAgent] = {}
         self.default_agent: DefaultAgent | None = None
-        self.config_intents: dict[str, Any] = {}
-        self.triggers_details: list[TriggerDetails] = []
+        self._intents: dict[IntentSource, IntentSourceConfig] = {
+            IntentSource.CONFIG: {"intents": {}},
+            IntentSource.TRIGGER: {"intents": {}},
+        }
+        self._intents_subscribers: list[IntentsCallback] = []
+        self._trigger_callbacks: dict[int, TRIGGER_CALLBACK_TYPE] = {}
+        self._trigger_callback_counter: int = 0
 
     @callback
     def async_get_agent(self, agent_id: str) -> AbstractConversationAgent | None:
@@ -200,27 +212,75 @@ class AgentManager:
 
     async def async_setup_default_agent(self, agent: DefaultAgent) -> None:
         """Set up the default agent."""
-        agent.update_config_intents(self.config_intents)
-        agent.update_triggers(self.triggers_details)
         self.default_agent = agent
 
+    @callback
+    def subscribe_intents(self, subscriber: IntentsCallback) -> CALLBACK_TYPE:
+        """Subscribe to intents updates.
+
+        The subscriber callback is called immediately with all intent sources
+        and whenever intents are updated (only with the changed source).
+        """
+        subscriber(self._intents)
+        self._intents_subscribers.append(subscriber)
+
+        @callback
+        def unsubscribe() -> None:
+            """Unsubscribe from intents updates."""
+            self._intents_subscribers.remove(subscriber)
+
+        return unsubscribe
+
+    def _notify_intents_subscribers(self, source: IntentSource) -> None:
+        """Notify all intents subscribers of a change to a specific source."""
+        update = {source: self._intents[source]}
+        for subscriber in self._intents_subscribers:
+            subscriber(update)
+
     def update_config_intents(self, intents: dict[str, Any]) -> None:
         """Update config intents."""
-        self.config_intents = intents
-        if self.default_agent is not None:
-            self.default_agent.update_config_intents(intents)
+        self._intents[IntentSource.CONFIG]["intents"] = intents
+        self._notify_intents_subscribers(IntentSource.CONFIG)
 
-    def register_trigger(self, trigger_details: TriggerDetails) -> CALLBACK_TYPE:
+    def register_trigger(
+        self, sentences: list[str], trigger_callback: TRIGGER_CALLBACK_TYPE
+    ) -> CALLBACK_TYPE:
         """Register a trigger."""
-        self.triggers_details.append(trigger_details)
-        if self.default_agent is not None:
-            self.default_agent.update_triggers(self.triggers_details)
+        trigger_id = self._trigger_callback_counter
+        self._trigger_callback_counter += 1
+        trigger_intent_name = f"{TRIGGER_INTENT_NAME_PREFIX}{trigger_id}"
+
+        trigger_intents = self._intents[IntentSource.TRIGGER]
+        trigger_intents["intents"][trigger_intent_name] = {
+            "data": [{"sentences": sentences}]
+        }
+        self._trigger_callbacks[trigger_id] = trigger_callback
+        self._notify_intents_subscribers(IntentSource.TRIGGER)
 
         @callback
         def unregister_trigger() -> None:
             """Unregister the trigger."""
-            self.triggers_details.remove(trigger_details)
-            if self.default_agent is not None:
-                self.default_agent.update_triggers(self.triggers_details)
+            del trigger_intents["intents"][trigger_intent_name]
+            del self._trigger_callbacks[trigger_id]
+            self._notify_intents_subscribers(IntentSource.TRIGGER)
 
         return unregister_trigger
+
+    @property
+    def trigger_sentences(self) -> list[str]:
+        """Get all trigger sentences."""
+        sentences: list[str] = []
+        trigger_intents = self._intents[IntentSource.TRIGGER]
+        for trigger_intent in trigger_intents.get("intents", {}).values():
+            for data in trigger_intent.get("data", []):
+                sentences.extend(data.get("sentences", []))
+        return sentences
+
+    def get_trigger_callback(
+        self, trigger_intent_name: str
+    ) -> TRIGGER_CALLBACK_TYPE | None:
+        """Get the callback for a trigger from its intent name."""
+        if not trigger_intent_name.startswith(TRIGGER_INTENT_NAME_PREFIX):
+            return None
+        trigger_id = int(trigger_intent_name[len(TRIGGER_INTENT_NAME_PREFIX) :])
+        return self._trigger_callbacks.get(trigger_id)

homeassistant/components/conversation/const.py

@@ -36,6 +36,13 @@ METADATA_CUSTOM_SENTENCE = "hass_custom_sentence"
 METADATA_CUSTOM_FILE = "hass_custom_file"
 
 
+class IntentSource(StrEnum):
+    """Source of intents."""
+
+    CONFIG = "config"
+    TRIGGER = "trigger"
+
+
 class ChatLogEventType(StrEnum):
     """Chat log event type."""
 

homeassistant/components/conversation/default_agent.py

@@ -76,18 +76,18 @@ from homeassistant.helpers.event import async_track_state_added_domain
 from homeassistant.util import language as language_util
 from homeassistant.util.json import JsonObjectType, json_loads_object
 
-from .agent_manager import get_agent_manager
+from .agent_manager import IntentSourceConfig, get_agent_manager
 from .chat_log import AssistantContent, ChatLog, ToolResultContent
 from .const import (
     DOMAIN,
     METADATA_CUSTOM_FILE,
     METADATA_CUSTOM_SENTENCE,
     ConversationEntityFeature,
+    IntentSource,
 )
 from .entity import ConversationEntity
 from .models import ConversationInput, ConversationResult
 from .trace import ConversationTraceEventType, async_conversation_trace_append
-from .trigger import TriggerDetails
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -126,7 +126,7 @@ class SentenceTriggerResult:
 
     sentence: str
     sentence_template: str | None
-    matched_triggers: dict[int, RecognizeResult]
+    matched_triggers: dict[str, RecognizeResult]
 
 
 class IntentMatchingStage(Enum):
@@ -236,15 +236,19 @@ class DefaultAgent(ConversationEntity):
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize the default agent."""
         self.hass = hass
+
         self._lang_intents: dict[str, LanguageIntents | object] = {}
         self._load_intents_lock = asyncio.Lock()
 
         # Intents from common conversation config
-        self._config_intents: dict[str, Any] = {}
+        self._config_intents_config: IntentSourceConfig = {}
 
-        # Sentences that will trigger a callback (skipping intent recognition)
-        self._triggers_details: list[TriggerDetails] = []
+        # Intents from conversation triggers
         self._trigger_intents: Intents | None = None
+        self._trigger_intents_config: IntentSourceConfig = {}
+
+        # Subscription to intents updates
+        self._unsub_intents: Callable[[], None] | None = None
 
         # Slot lists for entities, areas, etc.
         self._slot_lists: dict[str, SlotList] | None = None
@@ -261,6 +265,33 @@ class DefaultAgent(ConversationEntity):
         self.fuzzy_matching = True
         self._fuzzy_config: FuzzyConfig | None = None
 
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to intents updates when added to hass."""
+        self._unsub_intents = get_agent_manager(self.hass).subscribe_intents(
+            self._update_intents
+        )
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Unsubscribe from intents updates when removed from hass."""
+        if self._unsub_intents is not None:
+            self._unsub_intents()
+            self._unsub_intents = None
+
+    @callback
+    def _update_intents(
+        self, intents_update: dict[IntentSource, IntentSourceConfig]
+    ) -> None:
+        """Handle intents update from agent_manager subscription."""
+        if IntentSource.CONFIG in intents_update:
+            self._config_intents_config = intents_update[IntentSource.CONFIG]
+            # Intents have changed, so we must clear the cache
+            self._intent_cache.clear()
+
+        if IntentSource.TRIGGER in intents_update:
+            self._trigger_intents_config = intents_update[IntentSource.TRIGGER]
+            # Force rebuild on next use
+            self._trigger_intents = None
+
     @property
     def supported_languages(self) -> list[str]:
         """Return a list of supported languages."""
@@ -1059,14 +1090,6 @@ class DefaultAgent(ConversationEntity):
         # Intents have changed, so we must clear the cache
         self._intent_cache.clear()
 
-    @callback
-    def update_config_intents(self, intents: dict[str, Any]) -> None:
-        """Update config intents."""
-        self._config_intents = intents
-
-        # Intents have changed, so we must clear the cache
-        self._intent_cache.clear()
-
     async def async_prepare(self, language: str | None = None) -> None:
         """Load intents for a language."""
         if language is None:
@@ -1193,7 +1216,7 @@ class DefaultAgent(ConversationEntity):
 
         merge_dict(
             intents_dict,
-            self._config_intents,
+            self._config_intents_config,
         )
 
         if not intents_dict:
@@ -1461,27 +1484,12 @@ class DefaultAgent(ConversationEntity):
 
         return response_template.async_render(response_args)
 
-    @callback
-    def update_triggers(self, triggers_details: list[TriggerDetails]) -> None:
-        """Update triggers."""
-        self._triggers_details = triggers_details
-
-        # Force rebuild on next use
-        self._trigger_intents = None
-
     def _rebuild_trigger_intents(self) -> None:
-        """Rebuild the HassIL intents object from the current trigger sentences."""
+        """Rebuild the HassIL intents object from the trigger intents dict."""
         intents_dict = {
             "language": self.hass.config.language,
-            "intents": {
-                # Use trigger data index as a virtual intent name for HassIL.
-                # This works because the intents are rebuilt on every
-                # register/unregister.
-                str(trigger_id): {"data": [{"sentences": trigger_details.sentences}]}
-                for trigger_id, trigger_details in enumerate(self._triggers_details)
-            },
+            **self._trigger_intents_config,
         }
-
         trigger_intents = Intents.from_dict(intents_dict)
 
         # Assume slot list references are wildcards
@@ -1496,7 +1504,7 @@ class DefaultAgent(ConversationEntity):
 
         self._trigger_intents = trigger_intents
 
-        _LOGGER.debug("Rebuilt trigger intents: %s", intents_dict)
+        _LOGGER.debug("Rebuilt trigger intents: %s", self._trigger_intents_config)
 
     async def async_recognize_sentence_trigger(
         self, user_input: ConversationInput
@@ -1506,7 +1514,7 @@ class DefaultAgent(ConversationEntity):
         Calls the registered callbacks if there's a match and returns a sentence
         trigger result.
         """
-        if not self._triggers_details:
+        if not self._trigger_intents_config.get("intents"):
             # No triggers registered
             return None
 
@@ -1516,18 +1524,18 @@ class DefaultAgent(ConversationEntity):
 
         assert self._trigger_intents is not None
 
-        matched_triggers: dict[int, RecognizeResult] = {}
+        matched_triggers: dict[str, RecognizeResult] = {}
         matched_template: str | None = None
         for result in recognize_all(user_input.text, self._trigger_intents):
             if result.intent_sentence is not None:
                 matched_template = result.intent_sentence.text
 
-            trigger_id = int(result.intent.name)
-            if trigger_id in matched_triggers:
+            trigger_intent_name = result.intent.name
+            if trigger_intent_name in matched_triggers:
                 # Already matched a sentence from this trigger
                 break
 
-            matched_triggers[trigger_id] = result
+            matched_triggers[trigger_intent_name] = result
 
         if not matched_triggers:
             # Sentence did not match any trigger sentences
@@ -1551,10 +1559,14 @@ class DefaultAgent(ConversationEntity):
         chat_log: ChatLog,
     ) -> str:
         """Run sentence trigger callbacks and return response text."""
+        manager = get_agent_manager(self.hass)
+
         # Gather callback responses in parallel
         trigger_callbacks = [
-            self._triggers_details[trigger_id].callback(user_input, trigger_result)
-            for trigger_id, trigger_result in result.matched_triggers.items()
+            trigger_callback(user_input, trigger_result)
+            for trigger_intent_name, trigger_result in result.matched_triggers.items()
+            if (trigger_callback := manager.get_trigger_callback(trigger_intent_name))
+            is not None
         ]
 
         tool_input = llm.ToolInput(

homeassistant/components/conversation/http.py

@@ -165,11 +165,7 @@ async def websocket_list_sentences(
     """List custom registered sentences."""
     manager = get_agent_manager(hass)
 
-    sentences = []
-    for trigger_details in manager.triggers_details:
-        sentences.extend(trigger_details.sentences)
-
-    connection.send_result(msg["id"], {"trigger_sentences": sentences})
+    connection.send_result(msg["id"], {"trigger_sentences": manager.trigger_sentences})
 
 
 @websocket_api.websocket_command(

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.2.3"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.1.28"]
 }

homeassistant/components/conversation/trigger.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
 from typing import Any
 
 from hassil.recognize import RecognizeResult
@@ -31,14 +30,6 @@ TRIGGER_CALLBACK_TYPE = Callable[
 ]
 
 
-@dataclass(slots=True)
-class TriggerDetails:
-    """List of sentences and the callback for a trigger."""
-
-    sentences: list[str]
-    callback: TRIGGER_CALLBACK_TYPE
-
-
 def has_no_punctuation(value: list[str]) -> list[str]:
     """Validate result does not contain punctuation."""
     for sentence in value:
@@ -149,5 +140,5 @@ async def async_attach_trigger(
         return None
 
     return get_agent_manager(hass).register_trigger(
-        TriggerDetails(sentences=sentences, callback=call_action)
+        sentences=sentences, trigger_callback=call_action
     )

homeassistant/components/datadog/__init__.py

@@ -3,9 +3,8 @@
 import logging
 
 from datadog import DogStatsd, initialize
-import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_HOST,
     CONF_PORT,
@@ -16,53 +15,15 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, state as state_helper
-from homeassistant.helpers.typing import ConfigType
 
 from . import config_flow as config_flow
-from .const import (
-    CONF_RATE,
-    DEFAULT_HOST,
-    DEFAULT_PORT,
-    DEFAULT_PREFIX,
-    DEFAULT_RATE,
-    DOMAIN,
-)
+from .const import CONF_RATE, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
 type DatadogConfigEntry = ConfigEntry[DogStatsd]
 
-CONFIG_SCHEMA = vol.Schema(
-    {
-        DOMAIN: vol.Schema(
-            {
-                vol.Required(CONF_HOST, default=DEFAULT_HOST): cv.string,
-                vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
-                vol.Optional(CONF_PREFIX, default=DEFAULT_PREFIX): cv.string,
-                vol.Optional(CONF_RATE, default=DEFAULT_RATE): vol.All(
-                    vol.Coerce(int), vol.Range(min=1)
-                ),
-            }
-        )
-    },
-    extra=vol.ALLOW_EXTRA,
-)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Datadog integration from YAML, initiating config flow import."""
-    if DOMAIN not in config:
-        return True
-
-    hass.async_create_task(
-        hass.config_entries.flow.async_init(
-            DOMAIN,
-            context={"source": SOURCE_IMPORT},
-            data=config[DOMAIN],
-        )
-    )
-
-    return True
+CONFIG_SCHEMA = cv.removed(DOMAIN, raise_if_present=False)
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: DatadogConfigEntry) -> bool:

homeassistant/components/datadog/config_flow.py

@@ -12,8 +12,7 @@ from homeassistant.config_entries import (
     OptionsFlow,
 )
 from homeassistant.const import CONF_HOST, CONF_PORT, CONF_PREFIX
-from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant, callback
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
+from homeassistant.core import HomeAssistant, callback
 
 from .const import (
     CONF_RATE,
@@ -71,22 +70,6 @@ class DatadogConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def async_step_import(self, user_input: dict[str, Any]) -> ConfigFlowResult:
-        """Handle import from configuration.yaml."""
-        # Check for duplicates
-        self._async_abort_entries_match(
-            {CONF_HOST: user_input[CONF_HOST], CONF_PORT: user_input[CONF_PORT]}
-        )
-
-        result = await self.async_step_user(user_input)
-
-        if errors := result.get("errors"):
-            await deprecate_yaml_issue(self.hass, False)
-            return self.async_abort(reason=errors["base"])
-
-        await deprecate_yaml_issue(self.hass, True)
-        return result
-
     @staticmethod
     @callback
     def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
@@ -163,41 +146,3 @@ async def validate_datadog_connection(
         return False
     else:
         return True
-
-
-async def deprecate_yaml_issue(
-    hass: HomeAssistant,
-    import_success: bool,
-) -> None:
-    """Create an issue to deprecate YAML config."""
-    if import_success:
-        async_create_issue(
-            hass,
-            HOMEASSISTANT_DOMAIN,
-            f"deprecated_yaml_{DOMAIN}",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            breaks_in_ha_version="2026.2.0",
-            severity=IssueSeverity.WARNING,
-            translation_key="deprecated_yaml",
-            translation_placeholders={
-                "domain": DOMAIN,
-                "integration_title": "Datadog",
-            },
-        )
-    else:
-        async_create_issue(
-            hass,
-            DOMAIN,
-            "deprecated_yaml_import_connection_error",
-            breaks_in_ha_version="2026.2.0",
-            is_fixable=False,
-            issue_domain=DOMAIN,
-            severity=IssueSeverity.WARNING,
-            translation_key="deprecated_yaml_import_connection_error",
-            translation_placeholders={
-                "domain": DOMAIN,
-                "integration_title": "Datadog",
-                "url": f"/config/integrations/dashboard/add?domain={DOMAIN}",
-            },
-        )

homeassistant/components/datadog/strings.json

@@ -25,12 +25,6 @@
       }
     }
   },
-  "issues": {
-    "deprecated_yaml_import_connection_error": {
-      "description": "There was an error connecting to the Datadog Agent when trying to import the YAML configuration.\n\nEnsure the YAML configuration is correct and restart Home Assistant to try again or remove the {domain} configuration from your `configuration.yaml` file and continue to [set up the integration]({url}) manually.",
-      "title": "{domain} YAML configuration import failed"
-    }
-  },
   "options": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",

homeassistant/components/denonavr/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["denonavr"],
-  "requirements": ["denonavr==1.3.1"],
+  "requirements": ["denonavr==1.2.0"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/derivative/__init__.py

@@ -7,10 +7,7 @@ import logging
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_SOURCE, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device import (
-    async_entity_id_to_device_id,
-    async_remove_stale_devices_links_keep_entity_device,
-)
+from homeassistant.helpers.device import async_entity_id_to_device_id
 from homeassistant.helpers.helper_integration import (
     async_handle_source_entity_changes,
     async_remove_helper_config_entry_from_source_device,
@@ -22,11 +19,6 @@ _LOGGER = logging.getLogger(__name__)
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Derivative from a config entry."""
 
-    # This can be removed in HA Core 2026.2
-    async_remove_stale_devices_links_keep_entity_device(
-        hass, entry.entry_id, entry.options[CONF_SOURCE]
-    )
-
     def set_source_entity_id_or_uuid(source_entity_id: str) -> None:
         hass.config_entries.async_update_entry(
             entry,

homeassistant/components/dlink/data.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from datetime import datetime
 import logging
-import urllib
+import urllib.error
 
 from pyW215.pyW215 import SmartPlug
 

homeassistant/components/eafm/config_flow.py

@@ -41,13 +41,20 @@ class UKFloodsFlowHandler(ConfigFlow, domain=DOMAIN):
         self.stations = {}
         for station in stations:
             label = station["label"]
+            rloId = 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']
             if isinstance(label, list):
                 label = label[-1]
 
-            self.stations[label] = station["stationReference"]
+            # Similar for RLOIid
+            # E.g. 0018 has an RLOIid of ['10427', '9154']
+            if isinstance(rloId, list):
+                rloId = rloId[-1]
+
+            fullName = label + " - " + rloId
+            self.stations[fullName] = station["stationReference"]
 
         if not self.stations:
             return self.async_abort(reason="no_stations")

homeassistant/components/esphome/manifest.json

@@ -19,7 +19,7 @@
   "requirements": [
     "aioesphomeapi==43.14.0",
     "esphome-dashboard-api==1.3.0",
-    "bleak-esphome==3.6.0"
+    "bleak-esphome==3.5.0"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/flexit_bacnet/climate.py

@@ -4,6 +4,8 @@ import asyncio.exceptions
 from typing import Any
 
 from flexit_bacnet import (
+    OPERATION_MODE_FIREPLACE,
+    OPERATION_MODE_OFF,
     VENTILATION_MODE_AWAY,
     VENTILATION_MODE_HOME,
     VENTILATION_MODE_STOP,
@@ -12,7 +14,6 @@ from flexit_bacnet.bacnet import DecodingError
 
 from homeassistant.components.climate import (
     PRESET_AWAY,
-    PRESET_BOOST,
     PRESET_HOME,
     ClimateEntity,
     ClimateEntityFeature,
@@ -28,8 +29,10 @@ from .const import (
     DOMAIN,
     MAX_TEMP,
     MIN_TEMP,
+    OPERATION_TO_PRESET_MODE_MAP,
+    PRESET_FIREPLACE,
+    PRESET_HIGH,
     PRESET_TO_VENTILATION_MODE_MAP,
-    VENTILATION_TO_PRESET_MODE_MAP,
 )
 from .coordinator import FlexitConfigEntry, FlexitCoordinator
 from .entity import FlexitEntity
@@ -51,6 +54,7 @@ class FlexitClimateEntity(FlexitEntity, ClimateEntity):
     """Flexit air handling unit."""
 
     _attr_name = None
+    _attr_translation_key = "flexit_bacnet"
 
     _attr_hvac_modes = [
         HVACMode.OFF,
@@ -60,7 +64,8 @@ class FlexitClimateEntity(FlexitEntity, ClimateEntity):
     _attr_preset_modes = [
         PRESET_AWAY,
         PRESET_HOME,
-        PRESET_BOOST,
+        PRESET_HIGH,
+        PRESET_FIREPLACE,
     ]
 
     _attr_supported_features = (
@@ -127,20 +132,29 @@ class FlexitClimateEntity(FlexitEntity, ClimateEntity):
 
         Requires ClimateEntityFeature.PRESET_MODE.
         """
-        return VENTILATION_TO_PRESET_MODE_MAP[self.device.ventilation_mode]
+        return OPERATION_TO_PRESET_MODE_MAP[self.device.operation_mode]
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set new preset mode."""
-        ventilation_mode = PRESET_TO_VENTILATION_MODE_MAP[preset_mode]
-
         try:
-            await self.device.set_ventilation_mode(ventilation_mode)
+            if preset_mode == PRESET_FIREPLACE:
+                # Use trigger method for fireplace mode
+                await self.device.trigger_fireplace_mode()
+            else:
+                # If currently in fireplace mode, toggle it off first
+                # trigger_fireplace_mode() acts as a toggle
+                if self.device.operation_mode == OPERATION_MODE_FIREPLACE:
+                    await self.device.trigger_fireplace_mode()
+
+                # Set the desired ventilation mode
+                ventilation_mode = PRESET_TO_VENTILATION_MODE_MAP[preset_mode]
+                await self.device.set_ventilation_mode(ventilation_mode)
         except (asyncio.exceptions.TimeoutError, ConnectionError, DecodingError) as exc:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="set_preset_mode",
                 translation_placeholders={
-                    "preset": str(ventilation_mode),
+                    "preset": preset_mode,
                 },
             ) from exc
         finally:
@@ -149,7 +163,7 @@ class FlexitClimateEntity(FlexitEntity, ClimateEntity):
     @property
     def hvac_mode(self) -> HVACMode:
         """Return hvac operation ie. heat, cool mode."""
-        if self.device.ventilation_mode == VENTILATION_MODE_STOP:
+        if self.device.operation_mode == OPERATION_MODE_OFF:
             return HVACMode.OFF
 
         return HVACMode.FAN_ONLY

homeassistant/components/flexit_bacnet/const.py

@@ -1,34 +1,40 @@
 """Constants for the Flexit Nordic (BACnet) integration."""
 
 from flexit_bacnet import (
+    OPERATION_MODE_AWAY,
+    OPERATION_MODE_FIREPLACE,
+    OPERATION_MODE_HIGH,
+    OPERATION_MODE_HOME,
+    OPERATION_MODE_OFF,
     VENTILATION_MODE_AWAY,
     VENTILATION_MODE_HIGH,
     VENTILATION_MODE_HOME,
     VENTILATION_MODE_STOP,
 )
 
-from homeassistant.components.climate import (
-    PRESET_AWAY,
-    PRESET_BOOST,
-    PRESET_HOME,
-    PRESET_NONE,
-)
+from homeassistant.components.climate import PRESET_AWAY, PRESET_HOME, PRESET_NONE
 
 DOMAIN = "flexit_bacnet"
 
 MAX_TEMP = 30
 MIN_TEMP = 10
 
-VENTILATION_TO_PRESET_MODE_MAP = {
-    VENTILATION_MODE_STOP: PRESET_NONE,
-    VENTILATION_MODE_AWAY: PRESET_AWAY,
-    VENTILATION_MODE_HOME: PRESET_HOME,
-    VENTILATION_MODE_HIGH: PRESET_BOOST,
+PRESET_HIGH = "high"
+PRESET_FIREPLACE = "fireplace"
+
+# Map operation mode (what device reports) to Home Assistant preset
+OPERATION_TO_PRESET_MODE_MAP = {
+    OPERATION_MODE_OFF: PRESET_NONE,
+    OPERATION_MODE_AWAY: PRESET_AWAY,
+    OPERATION_MODE_HOME: PRESET_HOME,
+    OPERATION_MODE_HIGH: PRESET_HIGH,
+    OPERATION_MODE_FIREPLACE: PRESET_FIREPLACE,
 }
 
+# Map preset to ventilation mode (for setting standard modes)
 PRESET_TO_VENTILATION_MODE_MAP = {
     PRESET_NONE: VENTILATION_MODE_STOP,
     PRESET_AWAY: VENTILATION_MODE_AWAY,
     PRESET_HOME: VENTILATION_MODE_HOME,
-    PRESET_BOOST: VENTILATION_MODE_HIGH,
+    PRESET_HIGH: VENTILATION_MODE_HIGH,
 }

homeassistant/components/flexit_bacnet/icons.json

@@ -1,5 +1,17 @@
 {
   "entity": {
+    "climate": {
+      "flexit_bacnet": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "fireplace": "mdi:fireplace",
+              "high": "mdi:fan-speed-3"
+            }
+          }
+        }
+      }
+    },
     "number": {
       "away_extract_fan_setpoint": {
         "default": "mdi:fan-minus"

homeassistant/components/flexit_bacnet/strings.json

@@ -26,6 +26,18 @@
         "name": "Air filter polluted"
       }
     },
+    "climate": {
+      "flexit_bacnet": {
+        "state_attributes": {
+          "preset_mode": {
+            "state": {
+              "fireplace": "Fireplace",
+              "high": "High"
+            }
+          }
+        }
+      }
+    },
     "number": {
       "away_extract_fan_setpoint": {
         "name": "Away extract fan setpoint"
@@ -139,5 +151,11 @@
     "switch_turn": {
       "message": "Failed to turn the switch {state}."
     }
+  },
+  "issues": {
+    "deprecated_fireplace_switch": {
+      "description": "The fireplace mode switch entity `{entity_id}` is deprecated and will be removed in a future version.\n\nFireplace mode has been moved to a climate preset on the climate entity to better match the device interface.\n\nPlease update your automations to use the `climate.set_preset_mode` service with preset mode `fireplace` instead of using the switch entity.\n\nAfter updating your automations, you can safely disable this switch entity.",
+      "title": "Fireplace mode switch is deprecated"
+    }
   }
 }

homeassistant/components/flexit_bacnet/switch.py

@@ -13,9 +13,12 @@ from homeassistant.components.switch import (
     SwitchEntity,
     SwitchEntityDescription,
 )
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 
 from .const import DOMAIN
 from .coordinator import FlexitConfigEntry, FlexitCoordinator
@@ -39,13 +42,6 @@ SWITCHES: tuple[FlexitSwitchEntityDescription, ...] = (
         turn_on_fn=lambda data: data.enable_electric_heater(),
         turn_off_fn=lambda data: data.disable_electric_heater(),
     ),
-    FlexitSwitchEntityDescription(
-        key="fireplace_mode",
-        translation_key="fireplace_mode",
-        is_on_fn=lambda data: data.fireplace_ventilation_status,
-        turn_on_fn=lambda data: data.trigger_fireplace_mode(),
-        turn_off_fn=lambda data: data.trigger_fireplace_mode(),
-    ),
     FlexitSwitchEntityDescription(
         key="cooker_hood_mode",
         translation_key="cooker_hood_mode",
@@ -53,6 +49,13 @@ SWITCHES: tuple[FlexitSwitchEntityDescription, ...] = (
         turn_on_fn=lambda data: data.activate_cooker_hood(),
         turn_off_fn=lambda data: data.deactivate_cooker_hood(),
     ),
+    FlexitSwitchEntityDescription(
+        key="fireplace_mode",
+        translation_key="fireplace_mode",
+        is_on_fn=lambda data: data.fireplace_ventilation_status,
+        turn_on_fn=lambda data: data.trigger_fireplace_mode(),
+        turn_off_fn=lambda data: data.trigger_fireplace_mode(),
+    ),
 )
 
 
@@ -64,9 +67,42 @@ async def async_setup_entry(
     """Set up Flexit (bacnet) switch from a config entry."""
     coordinator = config_entry.runtime_data
 
-    async_add_entities(
-        FlexitSwitch(coordinator, description) for description in SWITCHES
-    )
+    entities: list[FlexitSwitch] = []
+    for description in SWITCHES:
+        if description.key == "fireplace_mode":
+            # Check if deprecated fireplace switch is enabled and create repair issue
+            entity_reg = er.async_get(hass)
+            fireplace_switch_unique_id = (
+                f"{coordinator.device.serial_number}-fireplace_mode"
+            )
+            # Look up the fireplace switch entity by unique_id
+            fireplace_switch_entity_id = entity_reg.async_get_entity_id(
+                Platform.SWITCH, DOMAIN, fireplace_switch_unique_id
+            )
+            if not fireplace_switch_entity_id:
+                continue
+            entity_registry_entry = entity_reg.async_get(fireplace_switch_entity_id)
+
+            if entity_registry_entry:
+                if entity_registry_entry.disabled:
+                    entity_reg.async_remove(fireplace_switch_entity_id)
+                else:
+                    async_create_issue(
+                        hass,
+                        DOMAIN,
+                        f"deprecated_switch_{fireplace_switch_unique_id}",
+                        is_fixable=False,
+                        issue_domain=DOMAIN,
+                        severity=IssueSeverity.WARNING,
+                        translation_key="deprecated_fireplace_switch",
+                        translation_placeholders={
+                            "entity_id": fireplace_switch_entity_id,
+                        },
+                    )
+                    entities.append(FlexitSwitch(coordinator, description))
+        else:
+            entities.append(FlexitSwitch(coordinator, description))
+        async_add_entities(entities)
 
 
 PARALLEL_UPDATES = 1

homeassistant/components/fressnapf_tracker/manifest.json

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

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260128.6"]
+  "requirements": ["home-assistant-frontend==20260128.3"]
 }

homeassistant/components/google/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["googleapiclient"],
-  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==12.1.3"]
+  "requirements": ["gcal-sync==8.0.0", "oauth2client==4.1.3", "ical==12.1.2"]
 }

homeassistant/components/growatt_server/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["growattServer"],
-  "requirements": ["growattServer==1.9.0"]
+  "requirements": ["growattServer==1.7.1"]
 }

homeassistant/components/hdfury/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/hdfury",
   "integration_type": "device",
   "iot_class": "local_polling",
-  "quality_scale": "silver",
+  "quality_scale": "gold",
   "requirements": ["hdfury==1.4.2"],
   "zeroconf": [
     { "name": "diva-*", "type": "_http._tcp.local." },

homeassistant/components/hdfury/quality_scale.yaml

@@ -46,24 +46,26 @@ rules:
   diagnostics: done
   discovery-update-info: done
   discovery: done
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done
-  docs-troubleshooting: todo
+  docs-troubleshooting: done
   docs-use-cases: done
   dynamic-devices:
     status: exempt
     comment: Device type integration.
   entity-category: done
   entity-device-class: done
-  entity-disabled-by-default: todo
+  entity-disabled-by-default: done
   entity-translations: done
   exception-translations: done
   icon-translations: done
   reconfiguration-flow: done
-  repair-issues: todo
+  repair-issues:
+    status: exempt
+    comment: The integration doesn't have any repair cases.
   stale-devices:
     status: exempt
     comment: Device type integration.

homeassistant/components/hikvision/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_push",
   "loggers": ["pyhik"],
   "quality_scale": "legacy",
-  "requirements": ["pyHik==0.4.2"]
+  "requirements": ["pyHik==0.4.1"]
 }

homeassistant/components/home_connect/binary_sensor.py

@@ -169,7 +169,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Connect binary sensor."""
     setup_home_connect_entry(
-        hass,
         entry,
         _get_entities_for_appliance,
         async_add_entities,

homeassistant/components/home_connect/button.py

@@ -73,7 +73,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Connect button entities."""
     setup_home_connect_entry(
-        hass,
         entry,
         _get_entities_for_appliance,
         async_add_entities,

homeassistant/components/home_connect/common.py

@@ -7,44 +7,18 @@ from typing import cast
 
 from aiohomeconnect.model import EventKey
 
-from homeassistant.const import Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry as er
-from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
 from .coordinator import HomeConnectApplianceData, HomeConnectConfigEntry
 from .entity import HomeConnectEntity, HomeConnectOptionEntity
 
 
-def should_add_option_entity(
-    description: EntityDescription,
-    appliance: HomeConnectApplianceData,
-    entity_registry: er.EntityRegistry,
-    platform: Platform,
-) -> bool:
-    """Check if the option entity should be added for the appliance.
-
-    This function returns `True` if the option is available in the appliance options
-    or if the entity was added in previous loads of this integration.
-    """
-    description_key = description.key
-    return description_key in appliance.options or (
-        entity_registry.async_get_entity_id(
-            platform, DOMAIN, f"{appliance.info.ha_id}-{description_key}"
-        )
-        is not None
-    )
-
-
 def _create_option_entities(
-    entity_registry: er.EntityRegistry,
     entry: HomeConnectConfigEntry,
     appliance: HomeConnectApplianceData,
     known_entity_unique_ids: dict[str, str],
     get_option_entities_for_appliance: Callable[
-        [HomeConnectConfigEntry, HomeConnectApplianceData, er.EntityRegistry],
+        [HomeConnectConfigEntry, HomeConnectApplianceData],
         list[HomeConnectOptionEntity],
     ],
     async_add_entities: AddConfigEntryEntitiesCallback,
@@ -52,9 +26,7 @@ def _create_option_entities(
     """Create the required option entities for the appliances."""
     option_entities_to_add = [
         entity
-        for entity in get_option_entities_for_appliance(
-            entry, appliance, entity_registry
-        )
+        for entity in get_option_entities_for_appliance(entry, appliance)
         if entity.unique_id not in known_entity_unique_ids
     ]
     known_entity_unique_ids.update(
@@ -67,14 +39,13 @@ def _create_option_entities(
 
 
 def _handle_paired_or_connected_appliance(
-    hass: HomeAssistant,
     entry: HomeConnectConfigEntry,
     known_entity_unique_ids: dict[str, str],
     get_entities_for_appliance: Callable[
         [HomeConnectConfigEntry, HomeConnectApplianceData], list[HomeConnectEntity]
     ],
     get_option_entities_for_appliance: Callable[
-        [HomeConnectConfigEntry, HomeConnectApplianceData, er.EntityRegistry],
+        [HomeConnectConfigEntry, HomeConnectApplianceData],
         list[HomeConnectOptionEntity],
     ]
     | None,
@@ -89,7 +60,6 @@ def _handle_paired_or_connected_appliance(
     already or it is the first time we see them when the appliance is connected.
     """
     entities: list[HomeConnectEntity] = []
-    entity_registry = er.async_get(hass)
     for appliance in entry.runtime_data.data.values():
         entities_to_add = [
             entity
@@ -99,9 +69,7 @@ def _handle_paired_or_connected_appliance(
         if get_option_entities_for_appliance:
             entities_to_add.extend(
                 entity
-                for entity in get_option_entities_for_appliance(
-                    entry, appliance, entity_registry
-                )
+                for entity in get_option_entities_for_appliance(entry, appliance)
                 if entity.unique_id not in known_entity_unique_ids
             )
             for event_key in (
@@ -112,7 +80,6 @@ def _handle_paired_or_connected_appliance(
                     entry.runtime_data.async_add_listener(
                         partial(
                             _create_option_entities,
-                            entity_registry,
                             entry,
                             appliance,
                             known_entity_unique_ids,
@@ -153,14 +120,13 @@ def _handle_depaired_appliance(
 
 
 def setup_home_connect_entry(
-    hass: HomeAssistant,
     entry: HomeConnectConfigEntry,
     get_entities_for_appliance: Callable[
         [HomeConnectConfigEntry, HomeConnectApplianceData], list[HomeConnectEntity]
     ],
     async_add_entities: AddConfigEntryEntitiesCallback,
     get_option_entities_for_appliance: Callable[
-        [HomeConnectConfigEntry, HomeConnectApplianceData, er.EntityRegistry],
+        [HomeConnectConfigEntry, HomeConnectApplianceData],
         list[HomeConnectOptionEntity],
     ]
     | None = None,
@@ -175,7 +141,6 @@ def setup_home_connect_entry(
         entry.runtime_data.async_add_special_listener(
             partial(
                 _handle_paired_or_connected_appliance,
-                hass,
                 entry,
                 known_entity_unique_ids,
                 get_entities_for_appliance,

homeassistant/components/home_connect/light.py

@@ -96,7 +96,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Connect light."""
     setup_home_connect_entry(
-        hass,
         entry,
         _get_entities_for_appliance,
         async_add_entities,

homeassistant/components/home_connect/number.py

@@ -11,13 +11,12 @@ from homeassistant.components.number import (
     NumberEntity,
     NumberEntityDescription,
 )
-from homeassistant.const import PERCENTAGE, Platform
+from homeassistant.const import PERCENTAGE
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .common import setup_home_connect_entry, should_add_option_entity
+from .common import setup_home_connect_entry
 from .const import DOMAIN, UNIT_MAP
 from .coordinator import HomeConnectApplianceData, HomeConnectConfigEntry
 from .entity import HomeConnectEntity, HomeConnectOptionEntity, constraint_fetcher
@@ -137,15 +136,12 @@ def _get_entities_for_appliance(
 def _get_option_entities_for_appliance(
     entry: HomeConnectConfigEntry,
     appliance: HomeConnectApplianceData,
-    entity_registry: er.EntityRegistry,
 ) -> list[HomeConnectOptionEntity]:
     """Get a list of currently available option entities."""
     return [
         HomeConnectOptionNumberEntity(entry.runtime_data, appliance, description)
         for description in NUMBER_OPTIONS
-        if should_add_option_entity(
-            description, appliance, entity_registry, Platform.NUMBER
-        )
+        if description.key in appliance.options
     ]
 
 
@@ -156,7 +152,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Connect number."""
     setup_home_connect_entry(
-        hass,
         entry,
         _get_entities_for_appliance,
         async_add_entities,

homeassistant/components/home_connect/select.py

@@ -11,13 +11,11 @@ from aiohomeconnect.model.error import HomeConnectError
 from aiohomeconnect.model.program import Execution
 
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
-from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .common import setup_home_connect_entry, should_add_option_entity
+from .common import setup_home_connect_entry
 from .const import (
     AVAILABLE_MAPS_ENUM,
     BEAN_AMOUNT_OPTIONS,
@@ -360,13 +358,12 @@ def _get_entities_for_appliance(
 def _get_option_entities_for_appliance(
     entry: HomeConnectConfigEntry,
     appliance: HomeConnectApplianceData,
-    entity_registry: er.EntityRegistry,
 ) -> list[HomeConnectOptionEntity]:
     """Get a list of entities."""
     return [
         HomeConnectSelectOptionEntity(entry.runtime_data, appliance, desc)
         for desc in PROGRAM_SELECT_OPTION_ENTITY_DESCRIPTIONS
-        if should_add_option_entity(desc, appliance, entity_registry, Platform.SELECT)
+        if desc.key in appliance.options
     ]
 
 
@@ -377,7 +374,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Connect select entities."""
     setup_home_connect_entry(
-        hass,
         entry,
         _get_entities_for_appliance,
         async_add_entities,

homeassistant/components/home_connect/sensor.py

@@ -115,6 +115,7 @@ SENSORS = (
         entity_category=EntityCategory.DIAGNOSTIC,
         native_unit_of_measurement=UnitOfVolume.MILLILITERS,
         device_class=SensorDeviceClass.VOLUME,
+        state_class=SensorStateClass.TOTAL_INCREASING,
         translation_key="hot_water_counter",
     ),
     HomeConnectSensorEntityDescription(
@@ -539,7 +540,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Connect sensor."""
     setup_home_connect_entry(
-        hass,
         entry,
         _get_entities_for_appliance,
         async_add_entities,

homeassistant/components/home_connect/switch.py

@@ -7,14 +7,12 @@ from aiohomeconnect.model import OptionKey, SettingKey
 from aiohomeconnect.model.error import HomeConnectError
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
-from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import UNDEFINED, UndefinedType
 
-from .common import setup_home_connect_entry, should_add_option_entity
+from .common import setup_home_connect_entry
 from .const import BSH_POWER_OFF, BSH_POWER_ON, BSH_POWER_STANDBY, DOMAIN
 from .coordinator import HomeConnectApplianceData, HomeConnectConfigEntry
 from .entity import HomeConnectEntity, HomeConnectOptionEntity
@@ -192,15 +190,12 @@ def _get_entities_for_appliance(
 def _get_option_entities_for_appliance(
     entry: HomeConnectConfigEntry,
     appliance: HomeConnectApplianceData,
-    entity_registry: er.EntityRegistry,
 ) -> list[HomeConnectOptionEntity]:
     """Get a list of currently available option entities."""
     return [
         HomeConnectSwitchOptionEntity(entry.runtime_data, appliance, description)
         for description in SWITCH_OPTIONS
-        if should_add_option_entity(
-            description, appliance, entity_registry, Platform.SWITCH
-        )
+        if description.key in appliance.options
     ]
 
 
@@ -211,7 +206,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Connect switch."""
     setup_home_connect_entry(
-        hass,
         entry,
         _get_entities_for_appliance,
         async_add_entities,

homeassistant/components/incomfort/manifest.json

@@ -12,5 +12,5 @@
   "iot_class": "local_polling",
   "loggers": ["incomfortclient"],
   "quality_scale": "platinum",
-  "requirements": ["incomfort-client==0.6.12"]
+  "requirements": ["incomfort-client==0.6.11"]
 }

homeassistant/components/incomfort/strings.json

@@ -90,7 +90,6 @@
           "boiler_int": "Boiler internal",
           "buffer": "Buffer",
           "central_heating": "Central heating",
-          "central_heating_low": "Central heating low",
           "central_heating_rf": "Central heating rf",
           "cv_temperature_too_high_e1": "Temperature too high",
           "flame_detection_fault_e6": "Flame detection fault",

homeassistant/components/input_number/strings.json

@@ -35,11 +35,11 @@
   },
   "services": {
     "decrement": {
-      "description": "Decrements the current value by 1 step.",
+      "description": "Decrements the value of an input number by 1 step.",
       "name": "Decrement"
     },
     "increment": {
-      "description": "Increments the current value by 1 step.",
+      "description": "Increments the value of an input number by 1 step.",
       "name": "Increment"
     },
     "reload": {
@@ -47,7 +47,7 @@
       "name": "[%key:common::action::reload%]"
     },
     "set_value": {
-      "description": "Sets the value.",
+      "description": "Sets the value of an input number.",
       "fields": {
         "value": {
           "description": "The target value.",

homeassistant/components/integration/__init__.py

@@ -7,10 +7,7 @@ import logging
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.device import (
-    async_entity_id_to_device_id,
-    async_remove_stale_devices_links_keep_entity_device,
-)
+from homeassistant.helpers.device import async_entity_id_to_device_id
 from homeassistant.helpers.helper_integration import (
     async_handle_source_entity_changes,
     async_remove_helper_config_entry_from_source_device,
@@ -24,13 +21,6 @@ _LOGGER = logging.getLogger(__name__)
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Integration from a config entry."""
 
-    # This can be removed in HA Core 2026.2
-    async_remove_stale_devices_links_keep_entity_device(
-        hass,
-        entry.entry_id,
-        entry.options[CONF_SOURCE_SENSOR],
-    )
-
     def set_source_entity_id_or_uuid(source_entity_id: str) -> None:
         hass.config_entries.async_update_entry(
             entry,

homeassistant/components/jellyfin/media_player.py

@@ -150,9 +150,7 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
 
         self._attr_state = state
         self._attr_is_volume_muted = volume_muted
-        # Only update volume_level if the API provides it, otherwise preserve current value
-        if volume_level is not None:
-            self._attr_volume_level = volume_level
+        self._attr_volume_level = volume_level
         self._attr_media_content_type = media_content_type
         self._attr_media_content_id = media_content_id
         self._attr_media_title = media_title
@@ -192,9 +190,7 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         )
         features = MediaPlayerEntityFeature(0)
 
-        if "PlayMediaSource" in commands or self.capabilities.get(
-            "SupportsMediaControl", False
-        ):
+        if "PlayMediaSource" in commands:
             features |= (
                 MediaPlayerEntityFeature.BROWSE_MEDIA
                 | MediaPlayerEntityFeature.PLAY_MEDIA
@@ -205,10 +201,10 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
                 | MediaPlayerEntityFeature.SEARCH_MEDIA
             )
 
-            if "Mute" in commands and "Unmute" in commands:
+            if "Mute" in commands:
                 features |= MediaPlayerEntityFeature.VOLUME_MUTE
 
-            if "VolumeSet" in commands or "SetVolume" in commands:
+            if "VolumeSet" in commands:
                 features |= MediaPlayerEntityFeature.VOLUME_SET
 
         return features
@@ -223,13 +219,11 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         """Send pause command."""
         self.coordinator.api_client.jellyfin.remote_pause(self.session_id)
         self._attr_state = MediaPlayerState.PAUSED
-        self.schedule_update_ha_state()
 
     def media_play(self) -> None:
         """Send play command."""
         self.coordinator.api_client.jellyfin.remote_unpause(self.session_id)
         self._attr_state = MediaPlayerState.PLAYING
-        self.schedule_update_ha_state()
 
     def media_play_pause(self) -> None:
         """Send the PlayPause command to the session."""
@@ -239,7 +233,6 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         """Send stop command."""
         self.coordinator.api_client.jellyfin.remote_stop(self.session_id)
         self._attr_state = MediaPlayerState.IDLE
-        self.schedule_update_ha_state()
 
     def play_media(
         self, media_type: MediaType | str, media_id: str, **kwargs: Any
@@ -254,8 +247,6 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         self.coordinator.api_client.jellyfin.remote_set_volume(
             self.session_id, int(volume * 100)
         )
-        self._attr_volume_level = volume
-        self.schedule_update_ha_state()
 
     def mute_volume(self, mute: bool) -> None:
         """Mute the volume."""
@@ -263,8 +254,6 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
             self.coordinator.api_client.jellyfin.remote_mute(self.session_id)
         else:
             self.coordinator.api_client.jellyfin.remote_unmute(self.session_id)
-        self._attr_is_volume_muted = mute
-        self.schedule_update_ha_state()
 
     async def async_browse_media(
         self,

homeassistant/components/jvc_projector/__init__.py

@@ -76,7 +76,7 @@ async def async_migrate_entities(
     def _update_entry(entry: RegistryEntry) -> dict[str, str] | None:
         """Fix unique_id of power binary_sensor entry."""
         if entry.domain == Platform.BINARY_SENSOR and ":" not in entry.unique_id:
-            if "_power" in entry.unique_id:
+            if entry.unique_id.endswith("_power"):
                 return {"new_unique_id": f"{coordinator.unique_id}_power"}
         return None
 

homeassistant/components/jvc_projector/binary_sensor.py

@@ -8,7 +8,6 @@ from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import POWER
 from .coordinator import JVCConfigEntry, JvcProjectorDataUpdateCoordinator
 from .entity import JvcProjectorEntity
 
@@ -41,4 +40,4 @@ class JvcBinarySensor(JvcProjectorEntity, BinarySensorEntity):
     @property
     def is_on(self) -> bool:
         """Return true if the JVC Projector is on."""
-        return self.coordinator.data[POWER] in ON_STATUS
+        return self.coordinator.data[cmd.Power.name] in ON_STATUS

homeassistant/components/jvc_projector/const.py

@@ -3,7 +3,3 @@
 NAME = "JVC Projector"
 DOMAIN = "jvc_projector"
 MANUFACTURER = "JVC"
-
-POWER = "power"
-INPUT = "input"
-SOURCE = "source"

homeassistant/components/jvc_projector/coordinator.py

@@ -2,29 +2,40 @@
 
 from __future__ import annotations
 
+import asyncio
 from datetime import timedelta
 import logging
 from typing import TYPE_CHECKING, Any
 
-from jvcprojector import (
-    JvcProjector,
-    JvcProjectorAuthError,
-    JvcProjectorTimeoutError,
-    command as cmd,
-)
+from jvcprojector import JvcProjector, JvcProjectorTimeoutError, command as cmd
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import INPUT, NAME, POWER
+from .const import NAME
+
+if TYPE_CHECKING:
+    from jvcprojector import Command
+
 
 _LOGGER = logging.getLogger(__name__)
 
 INTERVAL_SLOW = timedelta(seconds=10)
 INTERVAL_FAST = timedelta(seconds=5)
 
+CORE_COMMANDS: tuple[type[Command], ...] = (
+    cmd.Power,
+    cmd.Signal,
+    cmd.Input,
+    cmd.LightTime,
+)
+
+TRANSLATIONS = str.maketrans({"+": "p", "%": "p", ":": "x"})
+
+TIMEOUT_RETRIES = 12
+TIMEOUT_SLEEP = 1
+
 type JVCConfigEntry = ConfigEntry[JvcProjectorDataUpdateCoordinator]
 
 
@@ -51,27 +62,108 @@ class JvcProjectorDataUpdateCoordinator(DataUpdateCoordinator[dict[str, str]]):
             assert config_entry.unique_id is not None
         self.unique_id = config_entry.unique_id
 
+        self.capabilities = self.device.capabilities()
+
+        self.state: dict[type[Command], str] = {}
+
     async def _async_update_data(self) -> dict[str, Any]:
-        """Get the latest state data."""
-        state: dict[str, str | None] = {
-            POWER: None,
-            INPUT: None,
-        }
+        """Update state with the current value of a command."""
+        commands: set[type[Command]] = set(self.async_contexts())
+        commands = commands.difference(CORE_COMMANDS)
 
-        try:
-            state[POWER] = await self.device.get(cmd.Power)
+        last_timeout: JvcProjectorTimeoutError | None = None
 
-            if state[POWER] == cmd.Power.ON:
-                state[INPUT] = await self.device.get(cmd.Input)
+        for _ in range(TIMEOUT_RETRIES):
+            try:
+                new_state = await self._get_device_state(commands)
+                break
+            except JvcProjectorTimeoutError as err:
+                # Timeouts are expected when the projector loses signal and ignores commands for a brief time.
+                last_timeout = err
+                await asyncio.sleep(TIMEOUT_SLEEP)
+        else:
+            raise UpdateFailed(str(last_timeout)) from last_timeout
 
-        except JvcProjectorTimeoutError as err:
-            raise UpdateFailed(f"Unable to connect to {self.device.host}") from err
-        except JvcProjectorAuthError as err:
-            raise ConfigEntryAuthFailed("Password authentication failed") from err
+        # Clear state on signal loss
+        if (
+            new_state.get(cmd.Signal) == cmd.Signal.NONE
+            and self.state.get(cmd.Signal) != cmd.Signal.NONE
+        ):
+            self.state = {k: v for k, v in self.state.items() if k in CORE_COMMANDS}
 
-        if state[POWER] != cmd.Power.STANDBY:
+        # Update state with new values
+        for k, v in new_state.items():
+            self.state[k] = v
+
+        if self.state[cmd.Power] != cmd.Power.STANDBY:
             self.update_interval = INTERVAL_FAST
         else:
             self.update_interval = INTERVAL_SLOW
 
-        return state
+        return {k.name: v for k, v in self.state.items()}
+
+    async def _get_device_state(
+        self, commands: set[type[Command]]
+    ) -> dict[type[Command], str]:
+        """Get the current state of the device."""
+        new_state: dict[type[Command], str] = {}
+        deferred_commands: list[type[Command]] = []
+
+        power = await self._update_command_state(cmd.Power, new_state)
+
+        if power == cmd.Power.ON:
+            signal = await self._update_command_state(cmd.Signal, new_state)
+            await self._update_command_state(cmd.Input, new_state)
+            await self._update_command_state(cmd.LightTime, new_state)
+
+            if signal == cmd.Signal.SIGNAL:
+                for command in commands:
+                    if command.depends:
+                        # Command has dependencies so defer until below
+                        deferred_commands.append(command)
+                    else:
+                        await self._update_command_state(command, new_state)
+
+                # Deferred commands should have had dependencies met above
+                for command in deferred_commands:
+                    depend_command, depend_values = next(iter(command.depends.items()))
+                    value: str | None = None
+                    if depend_command in new_state:
+                        value = new_state[depend_command]
+                    elif depend_command in self.state:
+                        value = self.state[depend_command]
+                    if value and value in depend_values:
+                        await self._update_command_state(command, new_state)
+
+        elif self.state.get(cmd.Signal) != cmd.Signal.NONE:
+            new_state[cmd.Signal] = cmd.Signal.NONE
+
+        return new_state
+
+    async def _update_command_state(
+        self, command: type[Command], new_state: dict[type[Command], str]
+    ) -> str | None:
+        """Update state with the current value of a command."""
+        value = await self.device.get(command)
+
+        if value != self.state.get(command):
+            new_state[command] = value
+
+        return value
+
+    def get_options_map(self, command: str) -> dict[str, str]:
+        """Get the available options for a command."""
+        capabilities = self.capabilities.get(command, {})
+
+        if TYPE_CHECKING:
+            assert isinstance(capabilities, dict)
+            assert isinstance(capabilities.get("parameter", {}), dict)
+            assert isinstance(capabilities.get("parameter", {}).get("read", {}), dict)
+
+        values = list(capabilities.get("parameter", {}).get("read", {}).values())
+
+        return {v: v.translate(TRANSLATIONS) for v in values}
+
+    def supports(self, command: type[Command]) -> bool:
+        """Check if the device supports a command."""
+        return self.device.supports(command)

homeassistant/components/jvc_projector/entity.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 
-from jvcprojector import JvcProjector
+from jvcprojector import Command, JvcProjector
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -20,9 +20,13 @@ class JvcProjectorEntity(CoordinatorEntity[JvcProjectorDataUpdateCoordinator]):
 
     _attr_has_entity_name = True
 
-    def __init__(self, coordinator: JvcProjectorDataUpdateCoordinator) -> None:
+    def __init__(
+        self,
+        coordinator: JvcProjectorDataUpdateCoordinator,
+        command: type[Command] | None = None,
+    ) -> None:
         """Initialize the entity."""
-        super().__init__(coordinator)
+        super().__init__(coordinator, command)
 
         self._attr_unique_id = coordinator.unique_id
         self._attr_device_info = DeviceInfo(

homeassistant/components/jvc_projector/icons.json

@@ -1,7 +1,7 @@
 {
   "entity": {
     "binary_sensor": {
-      "jvc_power": {
+      "power": {
         "default": "mdi:projector-off",
         "state": {
           "on": "mdi:projector"
@@ -9,17 +9,47 @@
       }
     },
     "select": {
+      "anamorphic": {
+        "default": "mdi:fit-to-screen-outline"
+      },
+      "clear_motion_drive": {
+        "default": "mdi:blur"
+      },
+      "dynamic_control": {
+        "default": "mdi:lightbulb-on-outline"
+      },
       "input": {
         "default": "mdi:hdmi-port"
+      },
+      "installation_mode": {
+        "default": "mdi:aspect-ratio"
+      },
+      "light_power": {
+        "default": "mdi:lightbulb-on-outline"
       }
     },
     "sensor": {
-      "jvc_power_status": {
-        "default": "mdi:power-plug-off",
+      "color_depth": {
+        "default": "mdi:palette-outline"
+      },
+      "color_space": {
+        "default": "mdi:palette-outline"
+      },
+      "hdr": {
+        "default": "mdi:image-filter-hdr-outline"
+      },
+      "hdr_processing": {
+        "default": "mdi:image-filter-hdr-outline"
+      },
+      "picture_mode": {
+        "default": "mdi:movie-roll"
+      },
+      "power": {
+        "default": "mdi:power",
         "state": {
           "cooling": "mdi:snowflake",
           "error": "mdi:alert-circle",
-          "on": "mdi:power-plug",
+          "on": "mdi:power",
           "warming": "mdi:heat-wave"
         }
       }

homeassistant/components/jvc_projector/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["jvcprojector"],
-  "requirements": ["pyjvcprojector==2.0.0"]
+  "requirements": ["pyjvcprojector==2.0.1"]
 }

homeassistant/components/jvc_projector/remote.py

@@ -14,7 +14,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import POWER
 from .coordinator import JVCConfigEntry
 from .entity import JvcProjectorEntity
 
@@ -65,6 +64,8 @@ RENAMED_COMMANDS: dict[str, str] = {
     "hdmi2": cmd.Remote.HDMI2,
 }
 
+ON_STATUS = (cmd.Power.ON, cmd.Power.WARMING)
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -86,7 +87,7 @@ class JvcProjectorRemote(JvcProjectorEntity, RemoteEntity):
     @property
     def is_on(self) -> bool:
         """Return True if the entity is on."""
-        return self.coordinator.data[POWER] in (cmd.Power.ON, cmd.Power.WARMING)
+        return self.coordinator.data.get(cmd.Power.name) in ON_STATUS
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the device on."""

homeassistant/components/jvc_projector/select.py

@@ -2,11 +2,10 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import Final
 
-from jvcprojector import JvcProjector, command as cmd
+from jvcprojector import Command, command as cmd
 
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
 from homeassistant.core import HomeAssistant
@@ -20,17 +19,37 @@ from .entity import JvcProjectorEntity
 class JvcProjectorSelectDescription(SelectEntityDescription):
     """Describes JVC Projector select entities."""
 
-    command: Callable[[JvcProjector, str], Awaitable[None]]
+    command: type[Command]
 
 
-SELECTS: Final[list[JvcProjectorSelectDescription]] = [
+SELECTS: Final[tuple[JvcProjectorSelectDescription, ...]] = (
+    JvcProjectorSelectDescription(key="input", command=cmd.Input),
     JvcProjectorSelectDescription(
-        key="input",
-        translation_key="input",
-        options=[cmd.Input.HDMI1, cmd.Input.HDMI2],
-        command=lambda device, option: device.set(cmd.Input, option),
-    )
-]
+        key="installation_mode",
+        command=cmd.InstallationMode,
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSelectDescription(
+        key="light_power",
+        command=cmd.LightPower,
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSelectDescription(
+        key="dynamic_control",
+        command=cmd.DynamicControl,
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSelectDescription(
+        key="clear_motion_drive",
+        command=cmd.ClearMotionDrive,
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSelectDescription(
+        key="anamorphic",
+        command=cmd.Anamorphic,
+        entity_registry_enabled_default=False,
+    ),
+)
 
 
 async def async_setup_entry(
@@ -42,30 +61,45 @@ async def async_setup_entry(
     coordinator = entry.runtime_data
 
     async_add_entities(
-        JvcProjectorSelectEntity(coordinator, description) for description in SELECTS
+        JvcProjectorSelectEntity(coordinator, description)
+        for description in SELECTS
+        if coordinator.supports(description.command)
     )
 
 
 class JvcProjectorSelectEntity(JvcProjectorEntity, SelectEntity):
     """Representation of a JVC Projector select entity."""
 
-    entity_description: JvcProjectorSelectDescription
-
     def __init__(
         self,
         coordinator: JvcProjectorDataUpdateCoordinator,
         description: JvcProjectorSelectDescription,
     ) -> None:
         """Initialize the entity."""
-        super().__init__(coordinator)
+        super().__init__(coordinator, description.command)
+        self.command: type[Command] = description.command
+
         self.entity_description = description
-        self._attr_unique_id = f"{coordinator.unique_id}_{description.key}"
+        self._attr_translation_key = description.key
+        self._attr_unique_id = f"{self._attr_unique_id}_{description.key}"
+
+        self._options_map: dict[str, str] = coordinator.get_options_map(
+            self.command.name
+        )
+
+    @property
+    def options(self) -> list[str]:
+        """Return a list of selectable options."""
+        return list(self._options_map.values())
 
     @property
     def current_option(self) -> str | None:
         """Return the selected entity option to represent the entity state."""
-        return self.coordinator.data[self.entity_description.key]
+        if value := self.coordinator.data.get(self.command.name):
+            return self._options_map.get(value)
+        return None
 
     async def async_select_option(self, option: str) -> None:
         """Change the selected option."""
-        await self.entity_description.command(self.coordinator.device, option)
+        value = next((k for k, v in self._options_map.items() if v == option), None)
+        await self.coordinator.device.set(self.command, value)

homeassistant/components/jvc_projector/sensor.py

@@ -2,33 +2,77 @@
 
 from __future__ import annotations
 
-from jvcprojector import command as cmd
+from dataclasses import dataclass
+
+from jvcprojector import Command, command as cmd
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.const import EntityCategory
+from homeassistant.const import EntityCategory, UnitOfTime
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import JVCConfigEntry, JvcProjectorDataUpdateCoordinator
 from .entity import JvcProjectorEntity
 
-JVC_SENSORS = (
-    SensorEntityDescription(
+
+@dataclass(frozen=True, kw_only=True)
+class JvcProjectorSensorDescription(SensorEntityDescription):
+    """Describes JVC Projector sensor entities."""
+
+    command: type[Command]
+
+
+SENSORS: tuple[JvcProjectorSensorDescription, ...] = (
+    JvcProjectorSensorDescription(
         key="power",
-        translation_key="jvc_power_status",
+        command=cmd.Power,
+        device_class=SensorDeviceClass.ENUM,
+    ),
+    JvcProjectorSensorDescription(
+        key="light_time",
+        command=cmd.LightTime,
+        device_class=SensorDeviceClass.DURATION,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+    ),
+    JvcProjectorSensorDescription(
+        key="color_depth",
+        command=cmd.ColorDepth,
         device_class=SensorDeviceClass.ENUM,
         entity_category=EntityCategory.DIAGNOSTIC,
-        options=[
-            cmd.Power.STANDBY,
-            cmd.Power.ON,
-            cmd.Power.WARMING,
-            cmd.Power.COOLING,
-            cmd.Power.ERROR,
-        ],
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSensorDescription(
+        key="color_space",
+        command=cmd.ColorSpace,
+        device_class=SensorDeviceClass.ENUM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSensorDescription(
+        key="hdr",
+        command=cmd.Hdr,
+        device_class=SensorDeviceClass.ENUM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSensorDescription(
+        key="hdr_processing",
+        command=cmd.HdrProcessing,
+        device_class=SensorDeviceClass.ENUM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
+    ),
+    JvcProjectorSensorDescription(
+        key="picture_mode",
+        command=cmd.PictureMode,
+        device_class=SensorDeviceClass.ENUM,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        entity_registry_enabled_default=False,
     ),
 )
 
@@ -42,24 +86,48 @@ async def async_setup_entry(
     coordinator = entry.runtime_data
 
     async_add_entities(
-        JvcSensor(coordinator, description) for description in JVC_SENSORS
+        JvcProjectorSensorEntity(coordinator, description)
+        for description in SENSORS
+        if coordinator.supports(description.command)
     )
 
 
-class JvcSensor(JvcProjectorEntity, SensorEntity):
+class JvcProjectorSensorEntity(JvcProjectorEntity, SensorEntity):
     """The entity class for JVC Projector integration."""
 
     def __init__(
         self,
         coordinator: JvcProjectorDataUpdateCoordinator,
-        description: SensorEntityDescription,
+        description: JvcProjectorSensorDescription,
     ) -> None:
         """Initialize the JVC Projector sensor."""
-        super().__init__(coordinator)
+        super().__init__(coordinator, description.command)
+        self.command: type[Command] = description.command
+
         self.entity_description = description
-        self._attr_unique_id = f"{coordinator.unique_id}_{description.key}"
+        self._attr_translation_key = description.key
+        self._attr_unique_id = f"{self._attr_unique_id}_{description.key}"
+
+        self._options_map: dict[str, str] = {}
+        if self.device_class == SensorDeviceClass.ENUM:
+            self._options_map = coordinator.get_options_map(self.command.name)
+
+    @property
+    def options(self) -> list[str] | None:
+        """Return a set of possible options."""
+        if self.device_class == SensorDeviceClass.ENUM:
+            return list(self._options_map.values())
+        return None
 
     @property
     def native_value(self) -> str | None:
         """Return the native value."""
-        return self.coordinator.data[self.entity_description.key]
+        value = self.coordinator.data.get(self.command.name)
+
+        if value is None:
+            return None
+
+        if self.device_class == SensorDeviceClass.ENUM:
+            return self._options_map.get(value)
+
+        return value

homeassistant/components/jvc_projector/strings.json

@@ -36,20 +36,134 @@
   "entity": {
     "binary_sensor": {
       "power": {
-        "name": "[%key:component::binary_sensor::entity_component::power::name%]"
+        "name": "Power"
       }
     },
     "select": {
+      "anamorphic": {
+        "name": "Anamorphic",
+        "state": {
+          "a": "A",
+          "b": "B",
+          "c": "C",
+          "d": "D",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "clear_motion_drive": {
+        "name": "Clear Motion Drive",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "inverse-telecine": "Inverse Telecine",
+          "low": "[%key:common::state::low%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "dynamic_control": {
+        "name": "Dynamic Control",
+        "state": {
+          "balanced": "Balanced",
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "mode-1": "Mode 1",
+          "mode-2": "Mode 2",
+          "mode-3": "Mode 3",
+          "off": "[%key:common::state::off%]"
+        }
+      },
       "input": {
         "name": "Input",
         "state": {
           "hdmi1": "HDMI 1",
           "hdmi2": "HDMI 2"
         }
+      },
+      "installation_mode": {
+        "name": "Installation Mode",
+        "state": {
+          "memory-1": "Memory 1",
+          "memory-10": "Memory 10",
+          "memory-2": "Memory 2",
+          "memory-3": "Memory 3",
+          "memory-4": "Memory 4",
+          "memory-5": "Memory 5",
+          "memory-6": "Memory 6",
+          "memory-7": "Memory 7",
+          "memory-8": "Memory 8",
+          "memory-9": "Memory 9"
+        }
+      },
+      "light_power": {
+        "name": "Light Power",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "mid": "[%key:common::state::medium%]",
+          "normal": "[%key:common::state::normal%]"
+        }
       }
     },
     "sensor": {
-      "jvc_power_status": {
+      "color_depth": {
+        "name": "Color Depth",
+        "state": {
+          "8-bit": "8-bit",
+          "10-bit": "10-bit",
+          "12-bit": "12-bit"
+        }
+      },
+      "color_space": {
+        "name": "Color Space",
+        "state": {
+          "rgb": "RGB",
+          "xv-color": "XV Color",
+          "ycbcr-420": "YCbCr 4:2:0",
+          "ycbcr-422": "YCbCr 4:2:2",
+          "ycbcr-444": "YCbCr 4:4:4",
+          "yuv": "YUV"
+        }
+      },
+      "hdr": {
+        "name": "HDR",
+        "state": {
+          "hdr": "HDR",
+          "hdr10p": "HDR10+",
+          "hybrid-log": "Hybrid Log",
+          "none": "None",
+          "sdr": "SDR",
+          "smpte-st-2084": "SMPTE ST 2084"
+        }
+      },
+      "hdr_processing": {
+        "name": "HDR Processing",
+        "state": {
+          "frame-by-frame": "Frame-by-Frame",
+          "hdr10p": "HDR10+",
+          "scene-by-scene": "Scene-by-Scene",
+          "static": "Static"
+        }
+      },
+      "light_time": {
+        "name": "Light Time"
+      },
+      "picture_mode": {
+        "name": "Picture Mode",
+        "state": {
+          "frame-adapt-hdr": "Frame Adapt HDR",
+          "frame-adapt-hdr2": "Frame Adapt HDR2",
+          "frame-adapt-hdr3": "Frame Adapt HDR3",
+          "hdr1": "HDR1",
+          "hdr10": "HDR10",
+          "hdr10-ll": "HDR10 LL",
+          "hdr2": "HDR2",
+          "last-setting": "Last Setting",
+          "pana-pq": "Pana PQ",
+          "user-4": "User 4",
+          "user-5": "User 5",
+          "user-6": "User 6"
+        }
+      },
+      "power": {
         "name": "Status",
         "state": {
           "cooling": "Cooling",

homeassistant/components/knx/fan.py

@@ -2,19 +2,16 @@
 
 from __future__ import annotations
 
-import logging
 import math
 from typing import Any
 
 from propcache.api import cached_property
 from xknx.devices import Fan as XknxFan
-from xknx.telegram.address import parse_device_group_address
 
 from homeassistant import config_entries
 from homeassistant.components.fan import FanEntity, FanEntityFeature
 from homeassistant.const import CONF_ENTITY_CATEGORY, CONF_NAME, Platform
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry as er
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
     async_get_current_platform,
@@ -40,58 +37,6 @@ from .storage.const import (
 )
 from .storage.util import ConfigExtractor
 
-_LOGGER = logging.getLogger(__name__)
-
-
-@callback
-def async_migrate_yaml_uids(
-    hass: HomeAssistant, platform_config: list[ConfigType]
-) -> None:
-    """Migrate entities unique_id for YAML switch-only fan entities."""
-    # issue was introduced in 2026.1 - this migration in 2026.2
-    ent_reg = er.async_get(hass)
-    invalid_uid = str(None)
-    if (
-        none_entity_id := ent_reg.async_get_entity_id(Platform.FAN, DOMAIN, invalid_uid)
-    ) is None:
-        return
-    for config in platform_config:
-        if not config.get(KNX_ADDRESS) and (
-            new_uid_base := config.get(FanSchema.CONF_SWITCH_ADDRESS)
-        ):
-            break
-    else:
-        _LOGGER.info(
-            "No YAML entry found to migrate fan entity '%s' unique_id from '%s'. Removing entry",
-            none_entity_id,
-            invalid_uid,
-        )
-        ent_reg.async_remove(none_entity_id)
-        return
-    new_uid = str(
-        parse_device_group_address(
-            new_uid_base[0],  # list of group addresses - first item is sending address
-        )
-    )
-    try:
-        ent_reg.async_update_entity(none_entity_id, new_unique_id=str(new_uid))
-        _LOGGER.info(
-            "Migrating fan entity '%s' unique_id from '%s' to %s",
-            none_entity_id,
-            invalid_uid,
-            new_uid,
-        )
-    except ValueError:
-        # New unique_id already exists - remove invalid entry. User might have changed YAML
-        _LOGGER.info(
-            "Failed to migrate fan entity '%s' unique_id from '%s' to '%s'. "
-            "Removing the invalid entry",
-            none_entity_id,
-            invalid_uid,
-            new_uid,
-        )
-        ent_reg.async_remove(none_entity_id)
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -112,7 +57,6 @@ async def async_setup_entry(
 
     entities: list[_KnxFan] = []
     if yaml_platform_config := knx_module.config_yaml.get(Platform.FAN):
-        async_migrate_yaml_uids(hass, yaml_platform_config)
         entities.extend(
             KnxYamlFan(knx_module, entity_config)
             for entity_config in yaml_platform_config
@@ -233,10 +177,7 @@ class KnxYamlFan(_KnxFan, KnxYamlEntity):
         self._step_range: tuple[int, int] | None = (1, max_step) if max_step else None
         self._attr_entity_category = config.get(CONF_ENTITY_CATEGORY)
 
-        if self._device.speed.group_address:
-            self._attr_unique_id = str(self._device.speed.group_address)
-        else:
-            self._attr_unique_id = str(self._device.switch.group_address)
+        self._attr_unique_id = str(self._device.speed.group_address)
 
 
 class KnxUiFan(_KnxFan, KnxUiEntity):

homeassistant/components/liebherr/__init__.py

@@ -0,0 +1,67 @@
+"""The liebherr integration."""
+
+from __future__ import annotations
+
+import asyncio
+
+from pyliebherrhomeapi import LiebherrClient
+from pyliebherrhomeapi.exceptions import (
+    LiebherrAuthenticationError,
+    LiebherrConnectionError,
+)
+
+from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
+
+PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) -> bool:
+    """Set up Liebherr from a config entry."""
+    # Create shared API client
+    client = LiebherrClient(
+        api_key=entry.data[CONF_API_KEY],
+        session=async_get_clientsession(hass),
+    )
+
+    # Fetch device list to create coordinators
+    try:
+        devices = await client.get_devices()
+    except LiebherrAuthenticationError as err:
+        raise ConfigEntryError("Invalid API key") from err
+    except LiebherrConnectionError as err:
+        raise ConfigEntryNotReady(f"Failed to connect to Liebherr API: {err}") from err
+
+    # Create a coordinator for each device (may be empty if no devices)
+    coordinators: dict[str, LiebherrCoordinator] = {}
+    for device in devices:
+        coordinator = LiebherrCoordinator(
+            hass=hass,
+            config_entry=entry,
+            client=client,
+            device_id=device.device_id,
+        )
+        coordinators[device.device_id] = coordinator
+
+    await asyncio.gather(
+        *(
+            coordinator.async_config_entry_first_refresh()
+            for coordinator in coordinators.values()
+        )
+    )
+
+    # Store coordinators in runtime data
+    entry.runtime_data = coordinators
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/liebherr/config_flow.py

@@ -0,0 +1,68 @@
+"""Config flow for the liebherr integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from pyliebherrhomeapi import LiebherrClient
+from pyliebherrhomeapi.exceptions import (
+    LiebherrAuthenticationError,
+    LiebherrConnectionError,
+)
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_API_KEY): str,
+    }
+)
+
+
+class LiebherrConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for liebherr."""
+
+    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:
+            user_input[CONF_API_KEY] = user_input[CONF_API_KEY].strip()
+
+            self._async_abort_entries_match({CONF_API_KEY: user_input[CONF_API_KEY]})
+
+            try:
+                # Create a client and test the connection
+                client = LiebherrClient(
+                    api_key=user_input[CONF_API_KEY],
+                    session=async_get_clientsession(self.hass),
+                )
+                devices = await client.get_devices()
+            except LiebherrAuthenticationError:
+                errors["base"] = "invalid_auth"
+            except LiebherrConnectionError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                if not devices:
+                    return self.async_abort(reason="no_devices")
+
+                return self.async_create_entry(
+                    title="Liebherr",
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
+        )

homeassistant/components/liebherr/const.py

@@ -0,0 +1,6 @@
+"""Constants for the liebherr integration."""
+
+from typing import Final
+
+DOMAIN: Final = "liebherr"
+MANUFACTURER: Final = "Liebherr"

homeassistant/components/liebherr/coordinator.py

@@ -0,0 +1,75 @@
+"""DataUpdateCoordinator for Liebherr integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from pyliebherrhomeapi import (
+    DeviceState,
+    LiebherrAuthenticationError,
+    LiebherrClient,
+    LiebherrConnectionError,
+    LiebherrTimeoutError,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+type LiebherrConfigEntry = ConfigEntry[dict[str, LiebherrCoordinator]]
+
+_LOGGER = logging.getLogger(__name__)
+
+SCAN_INTERVAL = timedelta(seconds=60)
+
+
+class LiebherrCoordinator(DataUpdateCoordinator[DeviceState]):
+    """Class to manage fetching Liebherr data from the API for a single device."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: LiebherrConfigEntry,
+        client: LiebherrClient,
+        device_id: str,
+    ) -> None:
+        """Initialize coordinator."""
+        super().__init__(
+            hass,
+            logger=_LOGGER,
+            name=f"{DOMAIN}_{device_id}",
+            update_interval=SCAN_INTERVAL,
+            config_entry=config_entry,
+        )
+        self.client = client
+        self.device_id = device_id
+
+    async def _async_setup(self) -> None:
+        """Set up the coordinator by validating device access."""
+        try:
+            await self.client.get_device(self.device_id)
+        except LiebherrAuthenticationError as err:
+            raise ConfigEntryError("Invalid API key") from err
+        except LiebherrConnectionError as err:
+            raise ConfigEntryNotReady(
+                f"Failed to connect to device {self.device_id}: {err}"
+            ) from err
+
+    async def _async_update_data(self) -> DeviceState:
+        """Fetch data from API for this device."""
+        try:
+            return await self.client.get_device_state(self.device_id)
+        except LiebherrAuthenticationError as err:
+            raise ConfigEntryError("API key is no longer valid") from err
+        except LiebherrTimeoutError as err:
+            raise UpdateFailed(
+                f"Timeout communicating with device {self.device_id}"
+            ) from err
+        except LiebherrConnectionError as err:
+            raise UpdateFailed(
+                f"Error communicating with device {self.device_id}"
+            ) from err

homeassistant/components/liebherr/entity.py

@@ -0,0 +1,75 @@
+"""Base entity for Liebherr integration."""
+
+from __future__ import annotations
+
+from pyliebherrhomeapi import TemperatureControl, ZonePosition
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN, MANUFACTURER
+from .coordinator import LiebherrCoordinator
+
+# Zone position to translation key mapping
+ZONE_POSITION_MAP = {
+    ZonePosition.TOP: "top_zone",
+    ZonePosition.MIDDLE: "middle_zone",
+    ZonePosition.BOTTOM: "bottom_zone",
+}
+
+
+class LiebherrEntity(CoordinatorEntity[LiebherrCoordinator]):
+    """Base entity for Liebherr devices."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: LiebherrCoordinator,
+    ) -> None:
+        """Initialize the Liebherr entity."""
+        super().__init__(coordinator)
+
+        device = coordinator.data.device
+
+        model = None
+        if device.device_type:
+            model = device.device_type.title()
+
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, coordinator.device_id)},
+            name=device.nickname or device.device_name,
+            manufacturer=MANUFACTURER,
+            model=model,
+            model_id=device.device_name,
+        )
+
+
+class LiebherrZoneEntity(LiebherrEntity):
+    """Base entity for zone-based Liebherr entities.
+
+    This class should be used for entities that are associated with a specific
+    temperature control zone (e.g., climate, zone sensors).
+    """
+
+    def __init__(
+        self,
+        coordinator: LiebherrCoordinator,
+        zone_id: int,
+    ) -> None:
+        """Initialize the zone entity."""
+        super().__init__(coordinator)
+        self._zone_id = zone_id
+
+    @property
+    def temperature_control(self) -> TemperatureControl | None:
+        """Get the temperature control for this zone."""
+        return self.coordinator.data.get_temperature_controls().get(self._zone_id)
+
+    def _get_zone_translation_key(self) -> str | None:
+        """Get the translation key for this zone."""
+        control = self.temperature_control
+        if control and isinstance(control.zone_position, ZonePosition):
+            return ZONE_POSITION_MAP.get(control.zone_position)
+        # Fallback to None to use device model name
+        return None

homeassistant/components/liebherr/manifest.json

@@ -0,0 +1,18 @@
+{
+  "domain": "liebherr",
+  "name": "Liebherr",
+  "codeowners": ["@mettolen"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/liebherr",
+  "integration_type": "hub",
+  "iot_class": "cloud_polling",
+  "loggers": ["pyliebherrhomeapi"],
+  "quality_scale": "bronze",
+  "requirements": ["pyliebherrhomeapi==0.2.1"],
+  "zeroconf": [
+    {
+      "name": "liebherr*",
+      "type": "_http._tcp.local."
+    }
+  ]
+}

homeassistant/components/liebherr/quality_scale.yaml

@@ -0,0 +1,72 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: 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: 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:
+    status: exempt
+    comment: Integration does not register custom actions.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: Integration has no configurable parameters after initial setup.
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: Cloud API does not require updating entry data from network discovery.
+  discovery: done
+  docs-data-update: done
+  docs-examples: todo
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: No repair issues to implement at this time.
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: todo

homeassistant/components/liebherr/sensor.py

@@ -0,0 +1,118 @@
+"""Sensor platform for Liebherr integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from pyliebherrhomeapi import TemperatureControl, TemperatureUnit
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
+
+from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
+from .entity import LiebherrZoneEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class LiebherrSensorEntityDescription(SensorEntityDescription):
+    """Describes Liebherr sensor entity."""
+
+    value_fn: Callable[[TemperatureControl], StateType]
+    unit_fn: Callable[[TemperatureControl], str]
+
+
+SENSOR_TYPES: tuple[LiebherrSensorEntityDescription, ...] = (
+    LiebherrSensorEntityDescription(
+        key="temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+        value_fn=lambda control: control.value,
+        unit_fn=lambda control: (
+            UnitOfTemperature.FAHRENHEIT
+            if control.unit == TemperatureUnit.FAHRENHEIT
+            else UnitOfTemperature.CELSIUS
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: LiebherrConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Liebherr sensor entities."""
+    coordinators = entry.runtime_data
+    entities: list[LiebherrSensor] = []
+
+    for coordinator in coordinators.values():
+        # Get all temperature controls for this device
+        temp_controls = coordinator.data.get_temperature_controls()
+
+        for temp_control in temp_controls.values():
+            entities.extend(
+                LiebherrSensor(
+                    coordinator=coordinator,
+                    zone_id=temp_control.zone_id,
+                    description=description,
+                )
+                for description in SENSOR_TYPES
+            )
+
+    async_add_entities(entities)
+
+
+class LiebherrSensor(LiebherrZoneEntity, SensorEntity):
+    """Representation of a Liebherr sensor."""
+
+    entity_description: LiebherrSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: LiebherrCoordinator,
+        zone_id: int,
+        description: LiebherrSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor entity."""
+        super().__init__(coordinator, zone_id)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.device_id}_{description.key}_{zone_id}"
+
+        # If device has only one zone, use model name instead of zone name
+        temp_controls = coordinator.data.get_temperature_controls()
+        if len(temp_controls) == 1:
+            self._attr_name = None
+        else:
+            # Set translation key based on zone position for multi-zone devices
+            self._attr_translation_key = self._get_zone_translation_key()
+
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        """Return the unit of measurement."""
+        if (temp_control := self.temperature_control) is None:
+            return None
+        return self.entity_description.unit_fn(temp_control)
+
+    @property
+    def native_value(self) -> StateType:
+        """Return the current value."""
+        if (temp_control := self.temperature_control) is None:
+            return None
+        return self.entity_description.value_fn(temp_control)
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self.temperature_control is not None

homeassistant/components/liebherr/strings.json

@@ -0,0 +1,38 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "no_devices": "No devices found for this API key"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "no_devices": "No devices found for this API key",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "The API key from the Liebherr SmartDevice app. Note: The API key can only be copied once from the app."
+        },
+        "description": "Enter your Liebherr HomeAPI key. You can find it in the Liebherr SmartDevice app under Settings → Become a beta tester."
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "bottom_zone": {
+        "name": "Bottom zone"
+      },
+      "middle_zone": {
+        "name": "Middle zone"
+      },
+      "top_zone": {
+        "name": "Top zone"
+      }
+    }
+  }
+}

homeassistant/components/lifx/const.py

@@ -73,6 +73,3 @@ LIFX_CEILING_PRODUCT_IDS = {176, 177, 201, 202}
 LIFX_128ZONE_CEILING_PRODUCT_IDS = {201, 202}
 
 _LOGGER = logging.getLogger(__package__)
-
-# _ATTR_COLOR_TEMP deprecated - to be removed in 2026.1
-_ATTR_COLOR_TEMP = "color_temp"

homeassistant/components/lifx/manager.py

@@ -33,7 +33,7 @@ from homeassistant.helpers.target import (
     async_extract_referenced_entity_ids,
 )
 
-from .const import _ATTR_COLOR_TEMP, ATTR_THEME, DOMAIN
+from .const import ATTR_THEME, DOMAIN
 from .coordinator import LIFXUpdateCoordinator
 from .util import convert_8_to_16, find_hsbk
 
@@ -135,8 +135,6 @@ LIFX_EFFECT_PULSE_SCHEMA = cv.make_entity_service_schema(
         vol.Exclusive(ATTR_COLOR_TEMP_KELVIN, COLOR_GROUP): vol.All(
             vol.Coerce(int), vol.Range(min=1500, max=9000)
         ),
-        # _ATTR_COLOR_TEMP deprecated - to be removed in 2026.1
-        vol.Exclusive(_ATTR_COLOR_TEMP, COLOR_GROUP): cv.positive_int,
         ATTR_PERIOD: vol.All(vol.Coerce(float), vol.Range(min=0.05)),
         ATTR_CYCLES: vol.All(vol.Coerce(float), vol.Range(min=1)),
         ATTR_MODE: vol.In(PULSE_MODES),

homeassistant/components/lifx/util.py

@@ -26,7 +26,6 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.util import color as color_util
 
 from .const import (
-    _ATTR_COLOR_TEMP,
     _LOGGER,
     DEFAULT_ATTEMPTS,
     DOMAIN,
@@ -115,17 +114,6 @@ def find_hsbk(hass: HomeAssistant, **kwargs: Any) -> list[float | int | None] |
         saturation = int(saturation / 100 * 65535)
         kelvin = 3500
 
-    if ATTR_COLOR_TEMP_KELVIN not in kwargs and _ATTR_COLOR_TEMP in kwargs:
-        # added in 2025.1, can be removed in 2026.1
-        _LOGGER.warning(
-            "The 'color_temp' parameter is deprecated. Please use 'color_temp_kelvin' for"
-            " all service calls"
-        )
-        kelvin = color_util.color_temperature_mired_to_kelvin(
-            kwargs.pop(_ATTR_COLOR_TEMP)
-        )
-        saturation = 0
-
     if ATTR_COLOR_TEMP_KELVIN in kwargs:
         kelvin = kwargs.pop(ATTR_COLOR_TEMP_KELVIN)
         saturation = 0

homeassistant/components/local_calendar/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/local_calendar",
   "iot_class": "local_polling",
   "loggers": ["ical"],
-  "requirements": ["ical==12.1.3"]
+  "requirements": ["ical==12.1.2"]
 }

homeassistant/components/local_todo/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/local_todo",
   "iot_class": "local_polling",
-  "requirements": ["ical==12.1.3"]
+  "requirements": ["ical==12.1.2"]
 }

homeassistant/components/lovelace/strings.json

@@ -6,8 +6,8 @@
   },
   "issues": {
     "yaml_mode_deprecated": {
-      "description": "Your YAML dashboard configuration uses the legacy `mode: yaml` option, which will be removed in Home Assistant 2026.8. Your YAML dashboards will continue to work, you just need to update how they are defined.\n\nTo update your configuration:\n\n1. Remove `mode: yaml` from `lovelace:` in your `configuration.yaml`\n2. Add a dashboard entry instead:\n\n   ```yaml\n   lovelace:\n     resource_mode: yaml\n     dashboards:\n       lovelace:\n         mode: yaml\n         filename: {config_file}\n         title: Overview\n         icon: mdi:view-dashboard\n         show_in_sidebar: true\n   ```\n\n3. Restart Home Assistant\n\nNote: `resource_mode: yaml` keeps loading resources from YAML. If you want to manage resources through the UI instead, you can remove this line and move your resources to Settings > Dashboards > Resources.",
-      "title": "Lovelace YAML configuration needs update"
+      "description": "The `mode` option in `lovelace:` configuration is deprecated and will be removed in Home Assistant 2026.8.\n\nTo migrate:\n\n1. Remove `mode: yaml` from `lovelace:` in your `configuration.yaml`\n2. If you have `resources:` declared in your lovelace configuration, add `resource_mode: yaml` to keep loading resources from YAML\n3. Add a dashboard entry in your `configuration.yaml`:\n\n   ```yaml\n   lovelace:\n     resource_mode: yaml  # Add this if you have resources declared\n     dashboards:\n       lovelace:\n         mode: yaml\n         filename: {config_file}\n         title: Overview\n         icon: mdi:view-dashboard\n         show_in_sidebar: true\n   ```\n\n4. Restart Home Assistant",
+      "title": "Lovelace YAML mode deprecated"
     }
   },
   "services": {

homeassistant/components/matter/button.py

@@ -52,6 +52,22 @@ class MatterCommandButton(MatterEntity, ButtonEntity):
         await self.send_device_command(self.entity_description.command())
 
 
+class WindowCoveringCalibrationModeButton(MatterEntity, ButtonEntity):
+    """Button to set WindowCovering calibration mode bit to 1."""
+
+    async def async_press(self) -> None:
+        """Enable calibration mode by setting the CalibrationMode bit (bit 1)."""
+        calibration_bit = int(clusters.WindowCovering.Bitmaps.Mode.kCalibrationMode)
+        current_mode = self.get_matter_attribute_value(
+            clusters.WindowCovering.Attributes.Mode
+        )
+
+        if not isinstance(current_mode, int):
+            current_mode = 0
+        new_mode = current_mode | calibration_bit
+        await self.write_attribute(new_mode, clusters.WindowCovering.Attributes.Mode)
+
+
 # Discovery schema(s) to map Matter Attributes to HA entities
 DISCOVERY_SCHEMAS = [
     MatterDiscoverySchema(
@@ -155,6 +171,16 @@ DISCOVERY_SCHEMAS = [
         required_attributes=(clusters.SmokeCoAlarm.Attributes.AcceptedCommandList,),
         value_contains=clusters.SmokeCoAlarm.Commands.SelfTestRequest.command_id,
     ),
+    MatterDiscoverySchema(
+        platform=Platform.BUTTON,
+        entity_description=MatterButtonEntityDescription(
+            key="WindowCoveringCalibrationMode",
+            translation_key="calibration_mode",
+            entity_category=EntityCategory.CONFIG,
+        ),
+        entity_class=WindowCoveringCalibrationModeButton,
+        required_attributes=(clusters.WindowCovering.Attributes.Mode,),
+    ),
     MatterDiscoverySchema(
         platform=Platform.BUTTON,
         entity_description=MatterButtonEntityDescription(

homeassistant/components/matter/icons.json

@@ -6,6 +6,9 @@
       }
     },
     "button": {
+      "calibration_mode": {
+        "default": "mdi:window-shutter-cog"
+      },
       "pause": {
         "default": "mdi:pause"
       },

homeassistant/components/matter/strings.json

@@ -118,6 +118,9 @@
       }
     },
     "button": {
+      "calibration_mode": {
+        "name": "Calibration mode"
+      },
       "cancel_boost": {
         "name": "Cancel boost"
       },

homeassistant/components/media_extractor/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "calculated",
   "loggers": ["yt_dlp"],
   "quality_scale": "internal",
-  "requirements": ["yt-dlp[default]==2026.02.04"],
+  "requirements": ["yt-dlp[default]==2025.12.08"],
   "single_config_entry": true
 }

homeassistant/components/media_player/strings.json

@@ -266,7 +266,7 @@
       "name": "Browse media"
     },
     "clear_playlist": {
-      "description": "Removes all items from a media player's playlist.",
+      "description": "Removes all items from the playlist.",
       "name": "Clear playlist"
     },
     "join": {
@@ -284,15 +284,15 @@
       "name": "Next"
     },
     "media_pause": {
-      "description": "Pauses playback on a media player.",
+      "description": "Pauses.",
       "name": "[%key:common::action::pause%]"
     },
     "media_play": {
-      "description": "Starts playback on a media player.",
+      "description": "Starts playing.",
       "name": "Play"
     },
     "media_play_pause": {
-      "description": "Toggles play/pause on a media player.",
+      "description": "Toggles play/pause.",
       "name": "Play/Pause"
     },
     "media_previous_track": {
@@ -310,7 +310,7 @@
       "name": "Seek"
     },
     "media_stop": {
-      "description": "Stops playback on a media player.",
+      "description": "Stops playing.",
       "name": "[%key:common::action::stop%]"
     },
     "play_media": {
@@ -374,7 +374,7 @@
       "name": "Select sound mode"
     },
     "select_source": {
-      "description": "Sends a media player the command to change the input source.",
+      "description": "Sends the media player the command to change input source.",
       "fields": {
         "source": {
           "description": "Name of the source to switch to. Platform dependent.",
@@ -398,23 +398,23 @@
       "name": "[%key:common::action::toggle%]"
     },
     "turn_off": {
-      "description": "Turns off the power of a media player.",
+      "description": "Turns off the power of the media player.",
       "name": "[%key:common::action::turn_off%]"
     },
     "turn_on": {
-      "description": "Turns on the power of a media player.",
+      "description": "Turns on the power of the media player.",
       "name": "[%key:common::action::turn_on%]"
     },
     "unjoin": {
-      "description": "Removes a media player from a group. Only works on platforms which support player groups.",
+      "description": "Removes the player from a group. Only works on platforms which support player groups.",
       "name": "Unjoin"
     },
     "volume_down": {
-      "description": "Turns down the volume of a media player.",
+      "description": "Turns down the volume.",
       "name": "Turn down volume"
     },
     "volume_mute": {
-      "description": "Mutes or unmutes a media player.",
+      "description": "Mutes or unmutes the media player.",
       "fields": {
         "is_volume_muted": {
           "description": "Defines whether or not it is muted.",
@@ -424,7 +424,7 @@
       "name": "Mute/unmute volume"
     },
     "volume_set": {
-      "description": "Sets the volume level of a media player.",
+      "description": "Sets the volume level.",
       "fields": {
         "volume_level": {
           "description": "The volume. 0 is inaudible, 1 is the maximum volume.",
@@ -434,7 +434,7 @@
       "name": "Set volume"
     },
     "volume_up": {
-      "description": "Turns up the volume of a media player.",
+      "description": "Turns up the volume.",
       "name": "Turn up volume"
     }
   },

homeassistant/components/media_source/local_source.py

@@ -24,7 +24,7 @@ from .const import DOMAIN, MEDIA_CLASS_MAP, MEDIA_MIME_TYPES, MEDIA_SOURCE_DATA
 from .error import Unresolvable
 from .models import BrowseMediaSource, MediaSource, MediaSourceItem, PlayMedia
 
-MAX_UPLOAD_SIZE = 1024 * 1024 * 10
+MAX_UPLOAD_SIZE = 1024 * 1024 * 20
 LOGGER = logging.getLogger(__name__)
 
 

homeassistant/components/meteoclimatic/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["meteoclimatic"],
-  "requirements": ["pymeteoclimatic==0.1.1"]
+  "requirements": ["pymeteoclimatic==0.1.0"]
 }