Bump google-cloud-pubsub

# Conflicts:
#	requirements_test_all.txt

.github/workflows/ci.yaml

@@ -39,7 +39,7 @@ on:
 env:
   CACHE_VERSION: 3
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.6"
+  HA_SHORT_VERSION: "2026.7"
   ADDITIONAL_PYTHON_VERSIONS: "[]"
   # 10.3 is the oldest supported version
   # - 10.3.32 is the version currently shipped with Synology (as of 17 Feb 2022)

homeassistant/components/backup/backup.py

@@ -11,7 +11,7 @@ from homeassistant.helpers.hassio import is_hassio
 
 from .agent import BackupAgent, LocalBackupAgent, OnProgressCallback
 from .const import DOMAIN, LOGGER
-from .models import AgentBackup, BackupNotFound
+from .models import AgentBackup, BackupNotFound, InvalidBackupFilename
 from .util import read_backup, suggested_filename
 
 
@@ -54,7 +54,13 @@ class CoreLocalBackupAgent(LocalBackupAgent):
             try:
                 backup = read_backup(backup_path)
                 backups[backup.backup_id] = (backup, backup_path)
-            except (OSError, TarError, json.JSONDecodeError, KeyError) as err:
+            except (
+                OSError,
+                TarError,
+                json.JSONDecodeError,
+                KeyError,
+                InvalidBackupFilename,
+            ) as err:
                 LOGGER.warning("Unable to read backup %s: %s", backup_path, err)
         return backups
 
@@ -122,7 +128,14 @@ class CoreLocalBackupAgent(LocalBackupAgent):
 
     def get_new_backup_path(self, backup: AgentBackup) -> Path:
         """Return the local path to a new backup."""
-        return self._backup_dir / suggested_filename(backup)
+        candidate = self._backup_dir / suggested_filename(backup)
+        # suggested_filename does not strip separators; refuse paths that would
+        # land outside the backup directory.
+        if candidate.parent != self._backup_dir:
+            raise InvalidBackupFilename(
+                f"Refusing to write outside {self._backup_dir}: {candidate}"
+            )
+        return candidate
 
     async def async_delete_backup(self, backup_id: str, **kwargs: Any) -> None:
         """Delete a backup file."""

homeassistant/components/backup/manager.py

@@ -1978,7 +1978,13 @@ class CoreBackupReaderWriter(BackupReaderWriter):
 
         try:
             backup = await async_add_executor_job(read_backup, temp_file)
-        except (OSError, tarfile.TarError, json.JSONDecodeError, KeyError) as err:
+        except (
+            OSError,
+            tarfile.TarError,
+            json.JSONDecodeError,
+            KeyError,
+            InvalidBackupFilename,
+        ) as err:
             LOGGER.warning("Unable to parse backup %s: %s", temp_file, err)
             raise
 

homeassistant/components/backup/util.py

@@ -6,7 +6,7 @@ import copy
 from dataclasses import dataclass, replace
 from io import BytesIO
 import json
-from pathlib import Path, PurePath
+from pathlib import Path, PurePath, PureWindowsPath
 from queue import SimpleQueue
 import tarfile
 import threading
@@ -34,7 +34,7 @@ from homeassistant.util.async_iterator import (
 from homeassistant.util.json import JsonObjectType, json_loads_object
 
 from .const import BUF_SIZE, LOGGER, SECURETAR_CREATE_VERSION
-from .models import AddonInfo, AgentBackup, Folder
+from .models import AddonInfo, AgentBackup, Folder, InvalidBackupFilename
 
 
 class DecryptError(HomeAssistantError):
@@ -109,6 +109,13 @@ def read_backup(backup_path: Path) -> AgentBackup:
         extra_metadata = cast(dict[str, bool | str], data.get("extra", {}))
         date = extra_metadata.get("supervisor.backup_request_date", data["date"])
 
+        name = cast(str, data["name"])
+        # The name is used to derive the on-disk filename via suggested_filename;
+        # reject anything that could escape the backup directory.
+        safe_name = PureWindowsPath(name).name
+        if safe_name != name or name in ("", ".", ".."):
+            raise InvalidBackupFilename(f"Invalid backup name: {name!r}")
+
         return AgentBackup(
             addons=addons,
             backup_id=cast(str, data["slug"]),
@@ -118,7 +125,7 @@ def read_backup(backup_path: Path) -> AgentBackup:
             folders=folders,
             homeassistant_included=homeassistant_included,
             homeassistant_version=homeassistant_version,
-            name=cast(str, data["name"]),
+            name=name,
             protected=cast(bool, data.get("protected", False)),
             size=backup_path.stat().st_size,
         )

homeassistant/components/device_tracker/device_trigger.py

@@ -12,18 +12,13 @@ from homeassistant.const import (
     CONF_DOMAIN,
     CONF_ENTITY_ID,
     CONF_EVENT,
-    CONF_OPTIONS,
     CONF_PLATFORM,
     CONF_TYPE,
     CONF_ZONE,
 )
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant
 from homeassistant.helpers import config_validation as cv, entity_registry as er
-from homeassistant.helpers.trigger import (
-    TriggerActionType,
-    TriggerInfo,
-    _async_attach_trigger_cls,
-)
+from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
@@ -84,18 +79,16 @@ async def async_attach_trigger(
         event = zone.EVENT_ENTER
     else:
         event = zone.EVENT_LEAVE
-    zone_config = await zone.LegacyZoneTrigger.async_validate_config(
-        hass,
-        {
-            CONF_OPTIONS: {
-                CONF_ENTITY_ID: [config[CONF_ENTITY_ID]],
-                CONF_ZONE: config[CONF_ZONE],
-                CONF_EVENT: event,
-            }
-        },
-    )
-    return await _async_attach_trigger_cls(
-        hass, zone.LegacyZoneTrigger, "device", zone_config, action, trigger_info
+
+    zone_config = {
+        CONF_PLATFORM: ZONE_DOMAIN,
+        CONF_ENTITY_ID: config[CONF_ENTITY_ID],
+        CONF_ZONE: config[CONF_ZONE],
+        CONF_EVENT: event,
+    }
+    zone_config = await zone.async_validate_trigger_config(hass, zone_config)
+    return await zone.async_attach_trigger(
+        hass, zone_config, action, trigger_info, platform_type="device"
     )
 
 

homeassistant/components/device_tracker/entity.py

@@ -169,11 +169,35 @@ class BaseTrackerEntity(Entity):
     _attr_entity_category = EntityCategory.DIAGNOSTIC
     _attr_source_type: SourceType
 
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Post initialisation processing."""
+        super().__init_subclass__(**kwargs)
+        if "battery_level" in cls.__dict__:
+            if cls.__module__.startswith("homeassistant.components."):
+                # Don't ask users to report issue for built in integrations,
+                # they already have issues opened on them.
+                return
+            report_issue = async_suggest_report_issue(
+                async_get_hass_or_none(), module=cls.__module__
+            )
+            _LOGGER.warning(
+                (
+                    "%s::%s is overriding the deprecated battery_level property on "
+                    "a subclass of BaseTrackerEntity, this will be unsupported from "
+                    "Home Assistant 2027.7, please %s"
+                ),
+                cls.__module__,
+                cls.__name__,
+                report_issue,
+            )
+
     @cached_property
     def battery_level(self) -> int | None:
         """Return the battery level of the device.
 
         Percentage from 0-100.
+
+        The property is deprecated and will be removed in Home Assistant 2027.7.
         """
         return None
 

homeassistant/components/duckdns/coordinator.py

@@ -50,7 +50,7 @@ class DuckDnsUpdateCoordinator(DataUpdateCoordinator[None]):
         """Update Duck DNS."""
 
         retry_after = BACKOFF_INTERVALS[
-            min(self.failed, len(BACKOFF_INTERVALS))
+            min(self.failed, len(BACKOFF_INTERVALS) - 1)
         ].total_seconds()
 
         try:

homeassistant/components/google_cloud/manifest.json

@@ -8,7 +8,7 @@
   "integration_type": "service",
   "iot_class": "cloud_push",
   "requirements": [
-    "google-cloud-texttospeech==2.25.1",
-    "google-cloud-speech==2.31.1"
+    "google-cloud-texttospeech==2.36.0",
+    "google-cloud-speech==2.38.0"
   ]
 }

homeassistant/components/google_pubsub/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/google_pubsub",
   "iot_class": "cloud_push",
   "quality_scale": "legacy",
-  "requirements": ["google-cloud-pubsub==2.29.0"]
+  "requirements": ["google-cloud-pubsub==2.38.0"]
 }

homeassistant/components/google_travel_time/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["google", "homeassistant.helpers.location"],
-  "requirements": ["google-maps-routing==0.6.15"]
+  "requirements": ["google-maps-routing==0.10.0"]
 }

homeassistant/components/matter/sensor.py

@@ -439,6 +439,19 @@ DISCOVERY_SCHEMAS = [
         ),
         allow_multi=True,  # also used for climate entity
     ),
+    MatterDiscoverySchema(
+        platform=Platform.SENSOR,
+        entity_description=MatterSensorEntityDescription(
+            key="SoilMoistureSensor",
+            native_unit_of_measurement=PERCENTAGE,
+            device_class=SensorDeviceClass.MOISTURE,
+            state_class=SensorStateClass.MEASUREMENT,
+        ),
+        entity_class=MatterSensor,
+        required_attributes=(
+            clusters.SoilMeasurement.Attributes.SoilMoistureMeasuredValue,
+        ),
+    ),
     MatterDiscoverySchema(
         platform=Platform.SENSOR,
         entity_description=MatterSensorEntityDescription(

homeassistant/components/mqtt/strings.json

@@ -1140,7 +1140,7 @@
         },
         "step": {
           "confirm": {
-            "description": "Home Assistant is migrating to MQTT protocol version 5. The currently configured protocol version for broker {broker} is {protocol}. This protocol version is deprecated, and support for it will be removed.\n\nSubmitting this form will try to migrate your MQTT broker configuration to use protocol version 5 to fix this issue.",
+            "description": "Home Assistant needs to migrate to MQTT protocol version 5. The currently configured protocol version for broker {broker} is {protocol}. This protocol version is deprecated, and support for it will be removed.\n\nSubmitting this form will attempt to migrate your MQTT broker configuration to use protocol version 5 to fix this issue. If the broker cannot be reached using MQTT protocol version 5, for example because it does not support it, the migration will be aborted.",
             "title": "MQTT protocol change required"
           }
         }

homeassistant/components/mqtt/valve.py

@@ -271,7 +271,7 @@ class MqttValve(MqttEntity, ValveEntity):
                     self._range, float(position_payload)
                 )
             except ValueError:
-                _LOGGER.warning(
+                _LOGGER.debug(
                     "Ignoring non numeric payload '%s' received on topic '%s'",
                     position_payload,
                     msg.topic,
@@ -279,9 +279,9 @@ class MqttValve(MqttEntity, ValveEntity):
             else:
                 percentage_payload = min(max(percentage_payload, 0), 100)
                 self._attr_current_valve_position = percentage_payload
-                # Reset closing and opening if the valve is fully opened or fully closed
-                if state is None and percentage_payload in (0, 100):
-                    state = RESET_CLOSING_OPENING
+                # Reset opening/closing when a position update is received
+                # without an explicit opening/closing transitional state.
+                state = state or RESET_CLOSING_OPENING
                 position_set = True
         if state_payload and state is None and not position_set:
             _LOGGER.warning(
@@ -291,8 +291,6 @@ class MqttValve(MqttEntity, ValveEntity):
                 state_payload,
             )
             return
-        if state is None:
-            return
         self._update_state(state)
 
     @callback

homeassistant/components/ovhcloud_ai_endpoints/__init__.py

@@ -1,6 +1,12 @@
 """The OVHcloud AI Endpoints integration."""
 
-from openai import AsyncOpenAI, AuthenticationError, BadRequestError, OpenAIError
+from openai import (
+    AsyncOpenAI,
+    AuthenticationError,
+    BadRequestError,
+    OpenAIError,
+    PermissionDeniedError,
+)
 from openai.types.chat import ChatCompletionUserMessageParam
 
 from homeassistant.config_entries import ConfigEntry
@@ -52,7 +58,7 @@ async def async_setup_entry(
 
     try:
         await _validate_api_key(client)
-    except AuthenticationError as err:
+    except (AuthenticationError, PermissionDeniedError) as err:
         raise ConfigEntryAuthFailed(err) from err
     except OpenAIError as err:
         raise ConfigEntryNotReady(err) from err

homeassistant/components/ovhcloud_ai_endpoints/config_flow.py

@@ -1,9 +1,10 @@
 """Config flow for the OVHcloud AI Endpoints integration."""
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
-from openai import AsyncOpenAI, AuthenticationError, OpenAIError
+from openai import AsyncOpenAI, AuthenticationError, OpenAIError, PermissionDeniedError
 import voluptuous as vol
 
 from homeassistant.config_entries import (
@@ -30,6 +31,8 @@ from .const import CONF_PROMPT, DOMAIN, RECOMMENDED_CONVERSATION_OPTIONS
 
 _LOGGER = logging.getLogger(__name__)
 
+STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
+
 
 class OVHcloudAIEndpointsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for OVHcloud AI Endpoints."""
@@ -55,7 +58,7 @@ class OVHcloudAIEndpointsConfigFlow(ConfigFlow, domain=DOMAIN):
             client = _create_client(self.hass, user_input[CONF_API_KEY])
             try:
                 await _validate_api_key(client)
-            except AuthenticationError:
+            except AuthenticationError, PermissionDeniedError:
                 errors["base"] = "invalid_auth"
             except OpenAIError:
                 errors["base"] = "cannot_connect"
@@ -77,6 +80,39 @@ class OVHcloudAIEndpointsConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm reauthentication dialog."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            client = _create_client(self.hass, user_input[CONF_API_KEY])
+            try:
+                await _validate_api_key(client)
+            except AuthenticationError, PermissionDeniedError:
+                errors["base"] = "invalid_auth"
+            except OpenAIError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_update_reload_and_abort(
+                    self._get_reauth_entry(),
+                    data_updates=user_input,
+                )
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=STEP_REAUTH_DATA_SCHEMA,
+            errors=errors,
+        )
+
 
 class ConversationFlowHandler(ConfigSubentryFlow):
     """Handle conversation subentry flow."""

homeassistant/components/ovhcloud_ai_endpoints/quality_scale.yaml

@@ -44,7 +44,7 @@ rules:
     status: exempt
     comment: the integration only integrates stateless entities
   parallel-updates: todo
-  reauthentication-flow: todo
+  reauthentication-flow: done
   test-coverage: done
 
   # Gold

homeassistant/components/ovhcloud_ai_endpoints/strings.json

@@ -1,7 +1,8 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -9,6 +10,15 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
+      "reauth_confirm": {
+        "data": {
+          "api_key": "[%key:common::config_flow::data::api_key%]"
+        },
+        "data_description": {
+          "api_key": "[%key:component::ovhcloud_ai_endpoints::config::step::user::data_description::api_key%]"
+        },
+        "description": "The OVHcloud AI Endpoints API key is no longer valid. Please enter a new one."
+      },
       "user": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]"

homeassistant/components/wiim/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["wiim.sdk", "async_upnp_client"],
   "quality_scale": "bronze",
-  "requirements": ["wiim==0.1.2"],
+  "requirements": ["wiim==0.1.4"],
   "zeroconf": ["_linkplay._tcp.local."]
 }

homeassistant/components/wiim/media_player.py

@@ -349,15 +349,12 @@ class WiimMediaPlayerEntity(WiimBaseEntity, MediaPlayerEntity):
                     sdk_status_str,
                 )
             else:
-                self._device.playing_status = sdk_status
                 if sdk_status == SDKPlayingStatus.STOPPED:
                     LOGGER.debug(
                         "Device %s: TransportState is STOPPED."
                         " Resetting media position and metadata",
                         self.entity_id,
                     )
-                    self._device.current_position = 0
-                    self._device.current_track_duration = 0
                     self._attr_media_position_updated_at = None
                     self._attr_media_duration = None
                     self._attr_media_position = None

homeassistant/components/yamaha_musiccast/entity.py

@@ -63,7 +63,7 @@ class MusicCastDeviceEntity(MusicCastEntity):
             },
             manufacturer=BRAND,
             model=self.coordinator.data.model_name,
-            sw_version=self.coordinator.data.system_version,
+            sw_version=str(self.coordinator.data.system_version),
         )
 
         if self._zone_id == DEFAULT_ZONE:

homeassistant/components/zone/icons.json

@@ -3,19 +3,5 @@
     "reload": {
       "service": "mdi:reload"
     }
-  },
-  "triggers": {
-    "entered": {
-      "trigger": "mdi:map-marker-plus"
-    },
-    "left": {
-      "trigger": "mdi:map-marker-minus"
-    },
-    "occupancy_cleared": {
-      "trigger": "mdi:account-off"
-    },
-    "occupancy_detected": {
-      "trigger": "mdi:account-group"
-    }
   }
 }

homeassistant/components/zone/strings.json

@@ -1,74 +1,8 @@
 {
-  "common": {
-    "trigger_behavior_name": "Trigger when",
-    "trigger_for_name": "For at least",
-    "trigger_zone_description": "The zone to trigger on.",
-    "trigger_zone_name": "Zone"
-  },
   "services": {
     "reload": {
       "description": "Reloads zones from the YAML-configuration.",
       "name": "Reload zones"
     }
-  },
-  "triggers": {
-    "entered": {
-      "description": "Triggers when one or more persons or device trackers enter a zone.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::zone::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::zone::common::trigger_for_name%]"
-        },
-        "zone": {
-          "description": "[%key:component::zone::common::trigger_zone_description%]",
-          "name": "[%key:component::zone::common::trigger_zone_name%]"
-        }
-      },
-      "name": "Entered zone"
-    },
-    "left": {
-      "description": "Triggers when one or more persons or device trackers leave a zone.",
-      "fields": {
-        "behavior": {
-          "name": "[%key:component::zone::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::zone::common::trigger_for_name%]"
-        },
-        "zone": {
-          "description": "[%key:component::zone::common::trigger_zone_description%]",
-          "name": "[%key:component::zone::common::trigger_zone_name%]"
-        }
-      },
-      "name": "Left zone"
-    },
-    "occupancy_cleared": {
-      "description": "Triggers when a zone transitions from occupied to unoccupied.",
-      "fields": {
-        "for": {
-          "name": "[%key:component::zone::common::trigger_for_name%]"
-        },
-        "zone": {
-          "description": "[%key:component::zone::triggers::occupancy_detected::fields::zone::description%]",
-          "name": "[%key:component::zone::triggers::occupancy_detected::fields::zone::name%]"
-        }
-      },
-      "name": "Zone occupancy cleared"
-    },
-    "occupancy_detected": {
-      "description": "Triggers when a zone transitions to an occupied state.",
-      "fields": {
-        "for": {
-          "name": "[%key:component::zone::common::trigger_for_name%]"
-        },
-        "zone": {
-          "description": "The zone to monitor.",
-          "name": "Zone"
-        }
-      },
-      "name": "Zone occupancy detected"
-    }
   }
 }

homeassistant/components/zone/trigger.py

@@ -1,26 +1,22 @@
 """Offer zone automation rules."""
 
 import logging
-from typing import TYPE_CHECKING, Any, cast
 
 import voluptuous as vol
 
-from homeassistant.components.device_tracker import ATTR_IN_ZONES
 from homeassistant.const import (
     ATTR_FRIENDLY_NAME,
     CONF_ENTITY_ID,
     CONF_EVENT,
-    CONF_FOR,
-    CONF_OPTIONS,
-    CONF_TARGET,
+    CONF_PLATFORM,
     CONF_ZONE,
 )
 from homeassistant.core import (
     CALLBACK_TYPE,
     Event,
     EventStateChangedData,
+    HassJob,
     HomeAssistant,
-    State,
     callback,
 )
 from homeassistant.helpers import (
@@ -28,18 +24,8 @@ from homeassistant.helpers import (
     entity_registry as er,
     location,
 )
-from homeassistant.helpers.automation import (
-    DomainSpec,
-    move_top_level_schema_fields_to_options,
-)
 from homeassistant.helpers.event import async_track_state_change_event
-from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR,
-    EntityTriggerBase,
-    Trigger,
-    TriggerActionRunner,
-    TriggerConfig,
-)
+from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
 from homeassistant.helpers.typing import ConfigType
 
 from . import condition
@@ -52,232 +38,93 @@ _LOGGER = logging.getLogger(__name__)
 
 _EVENT_DESCRIPTION = {EVENT_ENTER: "entering", EVENT_LEAVE: "leaving"}
 
-_LEGACY_OPTIONS_SCHEMA: dict[vol.Marker, Any] = {
-    vol.Required(CONF_ENTITY_ID): cv.entity_ids_or_uuids,
-    vol.Required(CONF_ZONE): cv.entity_id,
-    vol.Required(CONF_EVENT, default=DEFAULT_EVENT): vol.Any(EVENT_ENTER, EVENT_LEAVE),
-}
-
-_LEGACY_TRIGGER_OPTIONS_SCHEMA = vol.Schema(
+_TRIGGER_SCHEMA = cv.TRIGGER_BASE_SCHEMA.extend(
     {
-        vol.Required(CONF_OPTIONS): _LEGACY_OPTIONS_SCHEMA,
-    },
-)
-
-# New-style zone trigger schema
-_ZONE_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR.extend(
-    {
-        vol.Required(CONF_OPTIONS): {
-            vol.Required(CONF_ZONE): cv.entity_domain("zone"),
-        },
+        vol.Required(CONF_PLATFORM): "zone",
+        vol.Required(CONF_ENTITY_ID): cv.entity_ids_or_uuids,
+        vol.Required(CONF_ZONE): cv.entity_id,
+        vol.Required(CONF_EVENT, default=DEFAULT_EVENT): vol.Any(
+            EVENT_ENTER, EVENT_LEAVE
+        ),
     }
 )
 
-_DOMAIN_SPECS: dict[str, DomainSpec] = {
-    "person": DomainSpec(),
-    "device_tracker": DomainSpec(),
-}
+
+async def async_validate_trigger_config(
+    hass: HomeAssistant, config: ConfigType
+) -> ConfigType:
+    """Validate trigger config."""
+    config = _TRIGGER_SCHEMA(config)
+    registry = er.async_get(hass)
+    config[CONF_ENTITY_ID] = er.async_validate_entity_ids(
+        registry, config[CONF_ENTITY_ID]
+    )
+    return config
 
 
-class LegacyZoneTrigger(Trigger):
-    """Legacy zone trigger (platform: zone)."""
+async def async_attach_trigger(
+    hass: HomeAssistant,
+    config: ConfigType,
+    action: TriggerActionType,
+    trigger_info: TriggerInfo,
+    *,
+    platform_type: str = "zone",
+) -> CALLBACK_TYPE:
+    """Listen for state changes based on configuration."""
+    trigger_data = trigger_info["trigger_data"]
+    entity_id: list[str] = config[CONF_ENTITY_ID]
+    zone_entity_id: str = config[CONF_ZONE]
+    event: str = config[CONF_EVENT]
+    job = HassJob(action)
 
-    @classmethod
-    async def async_validate_complete_config(
-        cls, hass: HomeAssistant, complete_config: ConfigType
-    ) -> ConfigType:
-        """Validate complete config, migrating legacy format to options."""
-        complete_config = move_top_level_schema_fields_to_options(
-            complete_config, _LEGACY_OPTIONS_SCHEMA
-        )
-        return await super().async_validate_complete_config(hass, complete_config)
+    @callback
+    def zone_automation_listener(zone_event: Event[EventStateChangedData]) -> None:
+        """Listen for state changes and calls action."""
+        entity = zone_event.data["entity_id"]
+        from_s = zone_event.data["old_state"]
+        to_s = zone_event.data["new_state"]
 
-    @classmethod
-    async def async_validate_config(
-        cls, hass: HomeAssistant, config: ConfigType
-    ) -> ConfigType:
-        """Validate config."""
-        config = cast(ConfigType, _LEGACY_TRIGGER_OPTIONS_SCHEMA(config))
-        registry = er.async_get(hass)
-        config[CONF_OPTIONS][CONF_ENTITY_ID] = er.async_validate_entity_ids(
-            registry, config[CONF_OPTIONS][CONF_ENTITY_ID]
-        )
-        return config
+        if (from_s and not location.has_location(from_s)) or (
+            to_s and not location.has_location(to_s)
+        ):
+            return
 
-    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
-        """Initialize trigger."""
-        super().__init__(hass, config)
-        if TYPE_CHECKING:
-            assert config.options is not None
-        self._options = config.options
-
-    async def async_attach_runner(
-        self, run_action: TriggerActionRunner
-    ) -> CALLBACK_TYPE:
-        """Listen for state changes based on configuration."""
-        entity_id: list[str] = self._options[CONF_ENTITY_ID]
-        zone_entity_id: str = self._options[CONF_ZONE]
-        event: str = self._options[CONF_EVENT]
-
-        @callback
-        def zone_automation_listener(zone_event: Event[EventStateChangedData]) -> None:
-            """Listen for state changes and calls action."""
-            entity = zone_event.data["entity_id"]
-            from_s = zone_event.data["old_state"]
-            to_s = zone_event.data["new_state"]
-
-            if (from_s and not location.has_location(from_s)) or (
-                to_s and not location.has_location(to_s)
-            ):
-                return
-
-            if not (zone_state := self._hass.states.get(zone_entity_id)):
-                _LOGGER.warning(
-                    "Non-existing zone '%s' in a zone trigger",
-                    zone_entity_id,
-                )
-                return
-
-            from_match = (
-                condition.zone(self._hass, zone_state, from_s) if from_s else False
+        if not (zone_state := hass.states.get(zone_entity_id)):
+            _LOGGER.warning(
+                (
+                    "Automation '%s' is referencing non-existing zone '%s' in a zone"
+                    " trigger"
+                ),
+                trigger_info["name"],
+                zone_entity_id,
             )
-            to_match = condition.zone(self._hass, zone_state, to_s) if to_s else False
+            return
 
-            if (event == EVENT_ENTER and not from_match and to_match) or (
-                event == EVENT_LEAVE and from_match and not to_match
-            ):
-                description = f"{entity} {_EVENT_DESCRIPTION[event]} {zone_state.attributes[ATTR_FRIENDLY_NAME]}"
-                run_action(
-                    {
+        from_match = condition.zone(hass, zone_state, from_s) if from_s else False
+        to_match = condition.zone(hass, zone_state, to_s) if to_s else False
+
+        if (event == EVENT_ENTER and not from_match and to_match) or (
+            event == EVENT_LEAVE and from_match and not to_match
+        ):
+            description = (
+                f"{entity} {_EVENT_DESCRIPTION[event]}"
+                f" {zone_state.attributes[ATTR_FRIENDLY_NAME]}"
+            )
+            hass.async_run_hass_job(
+                job,
+                {
+                    "trigger": {
+                        **trigger_data,
+                        "platform": platform_type,
                         "entity_id": entity,
                         "from_state": from_s,
                         "to_state": to_s,
                         "zone": zone_state,
                         "event": event,
-                    },
-                    description,
-                    to_s.context if to_s else None,
-                )
+                        "description": description,
+                    }
+                },
+                to_s.context if to_s else None,
+            )
 
-        return async_track_state_change_event(
-            self._hass, entity_id, zone_automation_listener
-        )
-
-
-class ZoneTriggerBase(EntityTriggerBase):
-    """Base for zone-based triggers targeting person and device_tracker entities."""
-
-    _domain_specs = _DOMAIN_SPECS
-    _schema = _ZONE_TRIGGER_SCHEMA
-
-    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
-        """Initialize the trigger."""
-        super().__init__(hass, config)
-        self._zone: str = self._options[CONF_ZONE]
-
-    def _in_target_zone(self, state: State) -> bool:
-        """Check if the entity is in the selected zone."""
-        in_zones = state.attributes.get(ATTR_IN_ZONES) or ()
-        return self._zone in in_zones
-
-
-class EnteredZoneTrigger(ZoneTriggerBase):
-    """Trigger when an entity enters the selected zone."""
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check that the entity was not already in the selected zone."""
-        return not self._in_target_zone(from_state)
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check that the entity is now in the selected zone."""
-        return self._in_target_zone(state)
-
-
-class LeftZoneTrigger(ZoneTriggerBase):
-    """Trigger when an entity leaves the selected zone."""
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check that the entity was previously in the selected zone."""
-        return self._in_target_zone(from_state)
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check that the entity is no longer in the selected zone."""
-        return not self._in_target_zone(state)
-
-
-_OCCUPANCY_TRIGGER_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_OPTIONS, default={}): {
-            vol.Required(CONF_ZONE): cv.entity_id,
-            vol.Optional(CONF_FOR): cv.positive_time_period,
-        },
-    }
-)
-
-
-class _ZoneOccupancyTriggerBase(EntityTriggerBase):
-    """Base for zone occupancy triggers (single zone, no behavior)."""
-
-    _domain_specs = {"zone": DomainSpec()}
-    _schema = _OCCUPANCY_TRIGGER_SCHEMA
-
-    @classmethod
-    async def async_validate_config(
-        cls, hass: HomeAssistant, config: ConfigType
-    ) -> ConfigType:
-        """Validate config and synthesize a target from the zone option."""
-        config = cast(ConfigType, cls._schema(config))
-        config[CONF_TARGET] = {CONF_ENTITY_ID: [config[CONF_OPTIONS][CONF_ZONE]]}
-        return config
-
-    @staticmethod
-    def _occupancy_count(state: State) -> int | None:
-        """Return the zone's persons-in-zone count; None if unparsable."""
-        try:
-            return int(state.state)
-        except TypeError, ValueError:
-            return None
-
-    @classmethod
-    def _is_occupied(cls, state: State) -> bool:
-        """Return True if the zone has at least one occupant."""
-        count = cls._occupancy_count(state)
-        return count is not None and count >= 1
-
-
-class OccupancyDetectedTrigger(_ZoneOccupancyTriggerBase):
-    """Trigger when a zone transitions to an occupied state."""
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check that the zone is occupied."""
-        return self._is_occupied(state)
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check that the zone was previously not occupied."""
-        return not self._is_occupied(from_state)
-
-
-class OccupancyClearedTrigger(_ZoneOccupancyTriggerBase):
-    """Trigger when a zone transitions from occupied to unoccupied."""
-
-    def is_valid_state(self, state: State) -> bool:
-        """Check that the zone is empty (count == 0)."""
-        return self._occupancy_count(state) == 0
-
-    def is_valid_transition(self, from_state: State, to_state: State) -> bool:
-        """Check that the zone was previously occupied."""
-        return self._is_occupied(from_state)
-
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "_": LegacyZoneTrigger,
-    "entered": EnteredZoneTrigger,
-    "left": LeftZoneTrigger,
-    "occupancy_detected": OccupancyDetectedTrigger,
-    "occupancy_cleared": OccupancyClearedTrigger,
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for zones."""
-    return TRIGGERS
+    return async_track_state_change_event(hass, entity_id, zone_automation_listener)

homeassistant/components/zone/triggers.yaml

@@ -1,42 +0,0 @@
-.trigger_zone: &trigger_zone
-  target:
-    entity:
-      domain:
-        - person
-        - device_tracker
-  fields:
-    behavior:
-      required: true
-      default: each
-      selector:
-        automation_behavior:
-          mode: trigger
-    for:
-      required: true
-      default: 00:00:00
-      selector:
-        duration:
-    zone:
-      required: true
-      selector:
-        entity:
-          domain: zone
-
-entered: *trigger_zone
-left: *trigger_zone
-
-.trigger_occupancy: &trigger_occupancy
-  fields:
-    for:
-      required: true
-      default: 00:00:00
-      selector:
-        duration:
-    zone:
-      required: true
-      selector:
-        entity:
-          domain: zone
-
-occupancy_detected: *trigger_occupancy
-occupancy_cleared: *trigger_occupancy

homeassistant/const.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 
 APPLICATION_NAME: Final = "HomeAssistant"
 MAJOR_VERSION: Final = 2026
-MINOR_VERSION: Final = 6
+MINOR_VERSION: Final = 7
 PATCH_VERSION: Final = "0.dev0"
 __short_version__: Final = f"{MAJOR_VERSION}.{MINOR_VERSION}"
 __version__: Final = f"{__short_version__}.{PATCH_VERSION}"

homeassistant/helpers/trigger.py

@@ -1714,14 +1714,7 @@ def async_extract_entities(trigger_conf: dict) -> list[str]:
         return [trigger_conf[CONF_OPTIONS][CONF_ENTITY_ID]]
 
     if trigger_conf[CONF_PLATFORM] == "zone":
-        options = trigger_conf[CONF_OPTIONS]
-        return [*options[CONF_ENTITY_ID], options[CONF_ZONE]]
-
-    if trigger_conf[CONF_PLATFORM] in ("zone.entered", "zone.left"):
-        return [
-            *async_extract_targets(trigger_conf, CONF_ENTITY_ID),
-            trigger_conf[CONF_OPTIONS][CONF_ZONE],
-        ]
+        return trigger_conf[CONF_ENTITY_ID] + [trigger_conf[CONF_ZONE]]  # type: ignore[no-any-return]
 
     if trigger_conf[CONF_PLATFORM] == "geo_location":
         return [trigger_conf[CONF_ZONE]]

homeassistant/package_constraints.txt

@@ -148,7 +148,7 @@ iso4217!=1.10.20220401
 
 # protobuf must be in package constraints for the wheel
 # builder to build binary wheels
-protobuf==6.32.0
+protobuf==7.34.1
 
 # faust-cchardet: Ensure we have a version we can build wheels
 # 2.1.18 is the first version that works with our wheel builder

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "homeassistant"
-version = "2026.6.0.dev0"
+version = "2026.7.0.dev0"
 license = "Apache-2.0"
 license-files = ["LICENSE*", "homeassistant/backports/LICENSE*"]
 description = "Open-source home automation platform running on Python 3."

requirements_all.txt

@@ -1122,19 +1122,19 @@ goodwe==0.4.10
 google-api-python-client==2.71.0
 
 # homeassistant.components.google_pubsub
-google-cloud-pubsub==2.29.0
+google-cloud-pubsub==2.38.0
 
 # homeassistant.components.google_cloud
-google-cloud-speech==2.31.1
+google-cloud-speech==2.38.0
 
 # homeassistant.components.google_cloud
-google-cloud-texttospeech==2.25.1
+google-cloud-texttospeech==2.36.0
 
 # homeassistant.components.google_generative_ai_conversation
 google-genai==1.59.0
 
 # homeassistant.components.google_travel_time
-google-maps-routing==0.6.15
+google-maps-routing==0.10.0
 
 # homeassistant.components.nest
 google-nest-sdm==9.1.2
@@ -3357,7 +3357,7 @@ whois==0.9.27
 wiffi==1.1.2
 
 # homeassistant.components.wiim
-wiim==0.1.2
+wiim==0.1.4
 
 # homeassistant.components.wirelesstag
 wirelesstagpy==0.8.1

requirements_test.txt

@@ -46,7 +46,7 @@ types-caldav==1.3.0.20250516
 types-chardet==0.1.5
 types-decorator==5.2.0.20260408
 types-pexpect==4.9.0.20260408
-types-protobuf==6.32.1.20260221
+types-protobuf==7.34.1.20260408
 types-psutil==7.2.2.20260408
 types-pyserial==3.5.0.20260408
 types-python-dateutil==2.9.0.20260408

script/gen_requirements_all.py

@@ -132,7 +132,7 @@ iso4217!=1.10.20220401
 
 # protobuf must be in package constraints for the wheel
 # builder to build binary wheels
-protobuf==6.32.0
+protobuf==7.34.1
 
 # faust-cchardet: Ensure we have a version we can build wheels
 # 2.1.18 is the first version that works with our wheel builder

tests/components/backup/test_manager.py

@@ -2088,6 +2088,36 @@ async def test_receive_backup_path_traversal(
     assert resp.status == 400
 
 
+@pytest.mark.parametrize(
+    "name",
+    [
+        "/absolute/path",
+        "../parent",
+        "with/slash",
+    ],
+)
+async def test_receive_backup_rejects_unsafe_inner_name(
+    hass: HomeAssistant,
+    hass_client: ClientSessionGenerator,
+    name: str,
+) -> None:
+    """Test receive backup rejects an inner name that would escape the backup dir."""
+    await setup_backup_integration(hass)
+    client = await hass_client()
+
+    backup = replace(TEST_BACKUP_ABC123, name=name)
+    with patch(
+        "homeassistant.components.backup.manager.read_backup",
+        return_value=backup,
+    ):
+        resp = await client.post(
+            "/api/backup/upload?agent_id=backup.local",
+            data={"file": StringIO("test")},
+        )
+
+    assert resp.status == 400
+
+
 async def test_receive_backup_busy_manager(
     hass: HomeAssistant,
     hass_client: ClientSessionGenerator,

tests/components/backup/test_util.py

@@ -14,6 +14,7 @@ import pytest
 import securetar
 
 from homeassistant.components.backup import DOMAIN, AddonInfo, AgentBackup, Folder
+from homeassistant.components.backup.models import InvalidBackupFilename
 from homeassistant.components.backup.util import (
     DecryptedBackupStreamer,
     EncryptedBackupStreamer,
@@ -158,6 +159,37 @@ def test_read_backup(backup_json_content: bytes, expected_backup: AgentBackup) -
         assert backup == expected_backup
 
 
+@pytest.mark.parametrize(
+    "name",
+    [
+        "/absolute/path",
+        "../parent",
+        "with/slash",
+        "with\\backslash",
+        "C:\\drive\\path",
+        "",
+        ".",
+        "..",
+    ],
+)
+def test_read_backup_rejects_unsafe_name(name: str) -> None:
+    """Test that read_backup rejects names that could escape the backup directory."""
+    backup_json_content = (
+        b'{"compressed":true,"date":"2024-12-02T07:23:58.261875-05:00","homeassistant":'
+        b'{"exclude_database":true,"version":"2024.12.0.dev0"},"name":"'
+        + name.encode().replace(b"\\", b"\\\\")
+        + b'","protected":true,"slug":"455645fe","type":"partial","version":2}'
+    )
+    mock_path = Mock()
+    mock_path.stat.return_value.st_size = 1234
+
+    with patch("homeassistant.components.backup.util.tarfile.open") as mock_open_tar:
+        tar_ctx = mock_open_tar.return_value.__enter__.return_value
+        tar_ctx.extractfile.return_value.read.return_value = backup_json_content
+        with pytest.raises(InvalidBackupFilename):
+            read_backup(mock_path)
+
+
 @pytest.mark.parametrize(
     ("backup", "password", "validation_result", "expected_messages"),
     [

tests/components/common.py

@@ -1586,12 +1586,12 @@ async def _validate_trigger_options(
     options: dict[str, Any] | None,
     *,
     valid: bool,
-    supports_target: bool = True,
 ) -> None:
     """Assert that a trigger accepts or rejects the given options during validation."""
-    trigger_config: dict[str, Any] = {CONF_PLATFORM: trigger}
-    if supports_target:
-        trigger_config[CONF_TARGET] = {ATTR_LABEL_ID: "test_label"}
+    trigger_config: dict[str, Any] = {
+        CONF_PLATFORM: trigger,
+        CONF_TARGET: {ATTR_LABEL_ID: "test_label"},
+    }
     if options is not None:
         trigger_config[CONF_OPTIONS] = options
     if valid:
@@ -1608,7 +1608,6 @@ async def assert_trigger_options_supported(
     *,
     supports_behavior: bool,
     supports_duration: bool,
-    supports_target: bool = True,
 ) -> None:
     """Assert which options a trigger supports.
 
@@ -1625,15 +1624,9 @@ async def assert_trigger_options_supported(
 
     # Minimal config should always be valid
     supports_empty = not bool(base_options)
-    await _validate_trigger_options(
-        hass, trigger, None, valid=supports_empty, supports_target=supports_target
-    )
-    await _validate_trigger_options(
-        hass, trigger, {}, valid=supports_empty, supports_target=supports_target
-    )
-    await _validate_trigger_options(
-        hass, trigger, base_options, valid=True, supports_target=supports_target
-    )
+    await _validate_trigger_options(hass, trigger, None, valid=supports_empty)
+    await _validate_trigger_options(hass, trigger, {}, valid=supports_empty)
+    await _validate_trigger_options(hass, trigger, base_options, valid=True)
 
     def _merge(extra: dict[str, Any]) -> dict[str, Any]:
         return {**(base_options or {}), **extra}
@@ -1641,30 +1634,18 @@ async def assert_trigger_options_supported(
     # Behavior
     for behavior in ("each", "first", "all"):
         await _validate_trigger_options(
-            hass,
-            trigger,
-            _merge({"behavior": behavior}),
-            valid=supports_behavior,
-            supports_target=supports_target,
+            hass, trigger, _merge({"behavior": behavior}), valid=supports_behavior
         )
 
     # Duration
     for for_value in ({"seconds": 5}, "00:00:05", 5):
         await _validate_trigger_options(
-            hass,
-            trigger,
-            _merge({"for": for_value}),
-            valid=supports_duration,
-            supports_target=supports_target,
+            hass, trigger, _merge({"for": for_value}), valid=supports_duration
         )
 
     # Unknown option should always be rejected
     await _validate_trigger_options(
-        hass,
-        trigger,
-        _merge({"unknown_option": True}),
-        valid=False,
-        supports_target=supports_target,
+        hass, trigger, _merge({"unknown_option": True}), valid=False
     )
 
 

tests/components/device_tracker/test_entity.py

@@ -1379,6 +1379,31 @@ def test_base_tracker_entity() -> None:
         entity.state_attributes  # noqa: B018
 
 
+def test_battery_level_override_deprecation_warning(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    """Test that overriding battery_level in a subclass logs a warning."""
+    error_message = "is overriding the deprecated battery_level property"
+
+    caplog.clear()
+
+    class _SubclassWithOverride(TrackerEntity):
+        @property
+        def battery_level(self) -> int | None:
+            return 50
+
+    assert error_message in caplog.text
+    assert _SubclassWithOverride.__name__ in caplog.text
+
+    # No warning for a subclass that does not override battery_level
+    caplog.clear()
+
+    class _SubclassWithoutOverride(TrackerEntity):
+        pass
+
+    assert error_message not in caplog.text
+
+
 async def test_attr_location_name_deprecation_warning(
     hass: HomeAssistant,
     caplog: pytest.LogCaptureFixture,

tests/components/matter/common.py

@@ -78,6 +78,7 @@ FIXTURES = [
     "mock_pressure_sensor",
     "mock_pump",
     "mock_room_airconditioner",
+    "mock_soil_sensor",
     "mock_solar_inverter",
     "mock_speaker",
     "mock_switch_unit",

tests/components/matter/fixtures/nodes/mock_soil_sensor.json

@@ -0,0 +1,87 @@
+{
+  "node_id": 101,
+  "date_commissioned": "2024-11-27T00:00:00.000000",
+  "last_interview": "2024-11-27T00:00:00.000000",
+  "interview_version": 2,
+  "attributes": {
+    "0/29/0": [
+      {
+        "0": 22,
+        "1": 1
+      }
+    ],
+    "0/29/1": [
+      4, 29, 31, 40, 42, 43, 44, 48, 49, 50, 51, 52, 53, 54, 55, 59, 60, 62, 63,
+      64, 65
+    ],
+    "0/29/2": [41],
+    "0/29/3": [1],
+    "0/29/65532": 0,
+    "0/29/65533": 1,
+    "0/29/65528": [],
+    "0/29/65529": [],
+    "0/29/65531": [0, 1, 2, 3, 65528, 65529, 65531, 65532, 65533],
+    "0/40/0": 1,
+    "0/40/1": "Nabu Casa",
+    "0/40/2": 65521,
+    "0/40/3": "Mock SoilSensor",
+    "0/40/4": 32768,
+    "0/40/5": "Mock Soil Sensor",
+    "0/40/6": "XX",
+    "0/40/7": 0,
+    "0/40/8": "v1.0",
+    "0/40/9": 1,
+    "0/40/10": "v1.0",
+    "0/40/11": "20241127",
+    "0/40/12": "",
+    "0/40/13": "",
+    "0/40/14": "",
+    "0/40/15": "TEST_SN",
+    "0/40/16": false,
+    "0/40/17": true,
+    "0/40/18": "mock-soil-sensor",
+    "0/40/19": {
+      "0": 3,
+      "1": 3
+    },
+    "0/40/65532": 0,
+    "0/40/65533": 1,
+    "0/40/65528": [],
+    "0/40/65529": [],
+    "0/40/65531": [
+      0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
+      65528, 65529, 65531, 65532, 65533
+    ],
+    "1/3/65529": [0, 64],
+    "1/3/65531": [0, 1, 65528, 65529, 65531, 65532, 65533],
+    "1/29/0": [
+      {
+        "0": 69,
+        "1": 1
+      }
+    ],
+    "1/29/1": [3, 29, 57, 1072, 40],
+    "1/29/2": [],
+    "1/29/3": [9, 10],
+    "1/29/65532": null,
+    "1/29/65533": 1,
+    "1/29/65528": [],
+    "1/29/65529": [],
+    "1/29/65531": [0, 1, 2, 3, 65528, 65529, 65531, 65532, 65533],
+    "1/1072/0": {
+      "0": 17,
+      "1": true,
+      "2": 0,
+      "3": 100,
+      "4": []
+    },
+    "1/1072/1": 50,
+    "1/1072/65532": 0,
+    "1/1072/65533": 1,
+    "1/1072/65528": [],
+    "1/1072/65529": [],
+    "1/1072/65531": [0, 1, 65528, 65529, 65531, 65532, 65533]
+  },
+  "available": true,
+  "attribute_subscriptions": []
+}

tests/components/matter/snapshots/test_sensor.ambr

@@ -18619,6 +18619,61 @@
     'state': '0.0',
   })
 # ---
+# name: test_sensors[mock_soil_sensor][sensor.mock_soil_sensor_moisture-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': list([
+      None,
+    ]),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.mock_soil_sensor_moisture',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Moisture',
+    'options': dict({
+    }),
+    'original_device_class': <SensorDeviceClass.MOISTURE: 'moisture'>,
+    'original_icon': None,
+    'original_name': 'Moisture',
+    'platform': 'matter',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': None,
+    'unique_id': '00000000000004D2-0000000000000065-MatterNodeDevice-1-SoilMoistureSensor-1072-1',
+    'unit_of_measurement': '%',
+  })
+# ---
+# name: test_sensors[mock_soil_sensor][sensor.mock_soil_sensor_moisture-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'moisture',
+      'friendly_name': 'Mock Soil Sensor Moisture',
+      'state_class': <SensorStateClass.MEASUREMENT: 'measurement'>,
+      'unit_of_measurement': '%',
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.mock_soil_sensor_moisture',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '50',
+  })
+# ---
 # name: test_sensors[mock_solar_inverter][sensor.mock_solar_inverter_active_current-entry]
   EntityRegistryEntrySnapshot({
     'aliases': list([

tests/components/matter/test_sensor.py

@@ -85,6 +85,25 @@ async def test_humidity_sensor(
     assert state.state == "40.0"
 
 
+@pytest.mark.parametrize("node_fixture", ["mock_soil_sensor"])
+async def test_soil_moisture_sensor(
+    hass: HomeAssistant,
+    matter_client: MagicMock,
+    matter_node: MatterNode,
+) -> None:
+    """Test soil moisture sensor."""
+    state = hass.states.get("sensor.mock_soil_sensor_moisture")
+    assert state
+    assert state.state == "50"
+
+    set_node_attribute(matter_node, 1, 1072, 1, 75)
+    await trigger_subscription_callback(hass, matter_client)
+
+    state = hass.states.get("sensor.mock_soil_sensor_moisture")
+    assert state
+    assert state.state == "75"
+
+
 @pytest.mark.parametrize("node_fixture", ["mock_light_sensor"])
 async def test_light_sensor(
     hass: HomeAssistant,

tests/components/mqtt/test_valve.py

@@ -270,7 +270,7 @@ async def test_state_via_state_topic_through_position(
 ) -> None:
     """Test the controlling state via topic through position.
 
-    Test is still possible to process a `opening` or `closing`
+    Test it is still possible to process a `opening` or `closing`
     state update. Additional we test json messages can be
     processed containing both position and state. Incoming
     rendered positions are clamped between 0..100.
@@ -308,7 +308,7 @@ async def test_opening_closing_state_is_reset(
 ) -> None:
     """Test the controlling state via topic through position.
 
-    Test a `opening` or `closing` state update is reset
+    Test an `opening` or `closing` state update is reset
     correctly after sequential updates.
     """
     await mqtt_mock_entry()
@@ -320,11 +320,13 @@ async def test_opening_closing_state_is_reset(
     messages = [
         ('{"position": 0, "state": "opening"}', ValveState.OPENING, 0),
         ('{"position": 50, "state": "opening"}', ValveState.OPENING, 50),
-        ('{"position": 60}', ValveState.OPENING, 60),
+        # Position-only update at intermediate position resets opening state
+        ('{"position": 60}', ValveState.OPEN, 60),
         ('{"position": 100, "state": "opening"}', ValveState.OPENING, 100),
         ('{"position": 100, "state": null}', ValveState.OPEN, 100),
         ('{"position": 90, "state": "closing"}', ValveState.CLOSING, 90),
-        ('{"position": 40}', ValveState.CLOSING, 40),
+        # Position-only update at intermediate position resets closing state
+        ('{"position": 40}', ValveState.OPEN, 40),
         ('{"position": 0}', ValveState.CLOSED, 0),
         ('{"position": 10}', ValveState.OPEN, 10),
         ('{"position": 0, "state": "opening"}', ValveState.OPENING, 0),
@@ -438,7 +440,7 @@ async def test_state_via_state_trough_position_with_alt_range(
     asserted_state: str,
     valve_position: int | None,
 ) -> None:
-    """Test controlling state via position with alternative range.
+    """Test controlling state via position with an alternative range.
 
     Test is still possible to process a `opening` or `closing`
     state update. Additional we test json messages can be

tests/components/ovhcloud_ai_endpoints/test_config_flow.py

@@ -246,3 +246,75 @@ async def test_subentry_entry_not_loaded(
 
     assert result["type"] is FlowResultType.ABORT
     assert result["reason"] == "entry_not_loaded"
+
+
+async def test_reauth_flow(
+    hass: HomeAssistant,
+    mock_openai_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test the reauth flow updates the API key."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await mock_config_entry.start_reauth_flow(hass)
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reauth_confirm"
+
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_API_KEY: "new_key"},
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "reauth_successful"
+    assert mock_config_entry.data[CONF_API_KEY] == "new_key"
+
+
+@pytest.mark.parametrize(
+    ("exception", "error"),
+    [
+        (
+            AuthenticationError(
+                message="invalid key",
+                response=httpx.Response(
+                    status_code=401,
+                    request=httpx.Request(method="POST", url="https://example.com"),
+                ),
+                body=None,
+            ),
+            "invalid_auth",
+        ),
+        (OpenAIError("boom"), "cannot_connect"),
+        (Exception("boom"), "unknown"),
+    ],
+)
+async def test_reauth_flow_errors(
+    hass: HomeAssistant,
+    mock_openai_client: AsyncMock,
+    mock_config_entry: MockConfigEntry,
+    exception: Exception,
+    error: str,
+) -> None:
+    """Test errors during reauth and recovery."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await mock_config_entry.start_reauth_flow(hass)
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "reauth_confirm"
+
+    mock_openai_client.chat.completions.create.side_effect = exception
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_API_KEY: "new_key"},
+    )
+    assert result["type"] is FlowResultType.FORM
+    assert result["errors"] == {"base": error}
+
+    mock_openai_client.chat.completions.create.side_effect = None
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"],
+        {CONF_API_KEY: "new_key"},
+    )
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "reauth_successful"
+    assert mock_config_entry.data[CONF_API_KEY] == "new_key"

tests/components/wiim/__init__.py

@@ -38,5 +38,6 @@ async def fire_transport_update(
     """Trigger the registered AVTransport callback on the mock device."""
     assert mock_device.av_transport_event_callback is not None
     mock_device.event_data = {"TransportState": transport_state.value}
+    mock_device.playing_status = transport_state
     mock_device.av_transport_event_callback(MagicMock(), [])
     await hass.async_block_till_done()

tests/components/zone/test_trigger.py

@@ -1,36 +1,14 @@
 """The tests for the location automation."""
 
-from datetime import timedelta
-from typing import Any
-
-from freezegun.api import FrozenDateTimeFactory
 import pytest
-import voluptuous as vol
 
 from homeassistant.components import automation, zone
-from homeassistant.const import (
-    ATTR_ENTITY_ID,
-    ENTITY_MATCH_ALL,
-    SERVICE_TURN_OFF,
-    STATE_UNAVAILABLE,
-    STATE_UNKNOWN,
-)
+from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, SERVICE_TURN_OFF
 from homeassistant.core import Context, HomeAssistant, ServiceCall
 from homeassistant.helpers import entity_registry as er
-from homeassistant.helpers.trigger import async_validate_trigger_config
 from homeassistant.setup import async_setup_component
 
-from tests.common import async_fire_time_changed, mock_component
-from tests.components.common import (
-    TriggerStateDescription,
-    assert_trigger_behavior_all,
-    assert_trigger_behavior_each,
-    assert_trigger_behavior_first,
-    assert_trigger_options_supported,
-    parametrize_target_entities,
-    parametrize_trigger_states,
-    target_entities,
-)
+from tests.common import mock_component
 
 
 @pytest.fixture(autouse=True)
@@ -365,7 +343,10 @@ async def test_unknown_zone(
         },
     )
 
-    assert "Non-existing zone 'zone.no_such_zone' in a zone trigger" not in caplog.text
+    assert (
+        "Automation 'My Automation' is referencing non-existing zone"
+        " 'zone.no_such_zone' in a zone trigger" not in caplog.text
+    )
 
     hass.states.async_set(
         "test.entity",
@@ -375,390 +356,7 @@ async def test_unknown_zone(
     )
     await hass.async_block_till_done()
 
-    assert "Non-existing zone 'zone.no_such_zone' in a zone trigger" in caplog.text
-
-
-# --- New-style zone trigger tests ---
-
-ZONE_HOME = "zone.home"
-ZONE_WORK = "zone.work"
-IN_ZONES_HOME = {"in_zones": [ZONE_HOME]}
-IN_ZONES_WORK = {"in_zones": [ZONE_WORK]}
-IN_ZONES_NONE: dict[str, list[str]] = {"in_zones": []}
-TRIGGER_ZONE = ZONE_HOME
-
-
-@pytest.mark.parametrize(
-    ("trigger_key", "base_options", "supports_behavior", "supports_duration"),
-    [
-        ("zone.entered", {"zone": TRIGGER_ZONE}, True, True),
-        ("zone.left", {"zone": TRIGGER_ZONE}, True, True),
-    ],
-)
-async def test_zone_trigger_options_validation(
-    hass: HomeAssistant,
-    trigger_key: str,
-    base_options: dict[str, Any] | None,
-    supports_behavior: bool,
-    supports_duration: bool,
-) -> None:
-    """Test that zone triggers support the expected options."""
-    await assert_trigger_options_supported(
-        hass,
-        trigger_key,
-        base_options,
-        supports_behavior=supports_behavior,
-        supports_duration=supports_duration,
+    assert (
+        "Automation 'My Automation' is referencing non-existing zone"
+        " 'zone.no_such_zone' in a zone trigger" in caplog.text
     )
-
-
-@pytest.mark.parametrize("trigger_key", ["zone.entered", "zone.left"])
-async def test_zone_trigger_rejects_non_zone_entity_id(
-    hass: HomeAssistant, trigger_key: str
-) -> None:
-    """Test that the zone option must reference entities in the zone domain."""
-    with pytest.raises(vol.Invalid):
-        await async_validate_trigger_config(
-            hass,
-            [
-                {
-                    "platform": trigger_key,
-                    "target": {"entity_id": "person.alice"},
-                    "options": {"zone": "person.alice"},
-                }
-            ],
-        )
-
-
-@pytest.fixture
-async def target_zone_entities(
-    hass: HomeAssistant, domain: str
-) -> dict[str, list[str]]:
-    """Create multiple zone-trackable entities associated with different targets."""
-    return await target_entities(hass, domain, domain_excluded="sensor")
-
-
-_ZONE_TRIGGER_STATES = [
-    *parametrize_trigger_states(
-        trigger="zone.entered",
-        trigger_options={"zone": TRIGGER_ZONE},
-        target_states=[
-            ("home", IN_ZONES_HOME),
-        ],
-        other_states=[
-            ("not_home", IN_ZONES_NONE),
-            ("Work", IN_ZONES_WORK),
-        ],
-    ),
-    *parametrize_trigger_states(
-        trigger="zone.left",
-        trigger_options={"zone": TRIGGER_ZONE},
-        target_states=[
-            ("not_home", IN_ZONES_NONE),
-            ("Work", IN_ZONES_WORK),
-        ],
-        other_states=[
-            ("home", IN_ZONES_HOME),
-        ],
-    ),
-]
-
-
-def _parametrize_zone_target_entities() -> list[tuple[dict[str, Any], str, int, str]]:
-    """Parametrize target entities for all supported zone trigger domains."""
-    return [
-        (*params, domain)
-        for domain in ("person", "device_tracker")
-        for params in parametrize_target_entities(domain)
-    ]
-
-
-@pytest.mark.parametrize(
-    ("trigger_target_config", "entity_id", "entities_in_target", "domain"),
-    _parametrize_zone_target_entities(),
-)
-@pytest.mark.parametrize(
-    ("trigger", "trigger_options", "states"),
-    _ZONE_TRIGGER_STATES,
-)
-async def test_zone_trigger_behavior_each(
-    hass: HomeAssistant,
-    target_zone_entities: dict[str, list[str]],
-    trigger_target_config: dict[str, Any],
-    entity_id: str,
-    entities_in_target: int,
-    trigger: str,
-    trigger_options: dict[str, Any],
-    states: list[TriggerStateDescription],
-) -> None:
-    """Test zone triggers fire when any targeted entity changes."""
-    await assert_trigger_behavior_each(
-        hass,
-        target_entities=target_zone_entities,
-        trigger_target_config=trigger_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
-        trigger=trigger,
-        trigger_options=trigger_options,
-        states=states,
-    )
-
-
-@pytest.mark.parametrize(
-    ("trigger_target_config", "entity_id", "entities_in_target", "domain"),
-    _parametrize_zone_target_entities(),
-)
-@pytest.mark.parametrize(
-    ("trigger", "trigger_options", "states"),
-    _ZONE_TRIGGER_STATES,
-)
-async def test_zone_trigger_behavior_first(
-    hass: HomeAssistant,
-    target_zone_entities: dict[str, list[str]],
-    trigger_target_config: dict[str, Any],
-    entity_id: str,
-    entities_in_target: int,
-    trigger: str,
-    trigger_options: dict[str, Any],
-    states: list[TriggerStateDescription],
-) -> None:
-    """Test zone triggers fire when first targeted entity changes."""
-    await assert_trigger_behavior_first(
-        hass,
-        target_entities=target_zone_entities,
-        trigger_target_config=trigger_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
-        trigger=trigger,
-        trigger_options=trigger_options,
-        states=states,
-    )
-
-
-@pytest.mark.parametrize(
-    ("trigger_target_config", "entity_id", "entities_in_target", "domain"),
-    _parametrize_zone_target_entities(),
-)
-@pytest.mark.parametrize(
-    ("trigger", "trigger_options", "states"),
-    _ZONE_TRIGGER_STATES,
-)
-async def test_zone_trigger_behavior_all(
-    hass: HomeAssistant,
-    target_zone_entities: dict[str, list[str]],
-    trigger_target_config: dict[str, Any],
-    entity_id: str,
-    entities_in_target: int,
-    trigger: str,
-    trigger_options: dict[str, Any],
-    states: list[TriggerStateDescription],
-) -> None:
-    """Test zone triggers fire when last targeted entity changes."""
-    await assert_trigger_behavior_all(
-        hass,
-        target_entities=target_zone_entities,
-        trigger_target_config=trigger_target_config,
-        entity_id=entity_id,
-        entities_in_target=entities_in_target,
-        trigger=trigger,
-        trigger_options=trigger_options,
-        states=states,
-    )
-
-
-# --- Zone occupancy trigger tests ---
-
-
-@pytest.mark.usefixtures("enable_labs_preview_features")
-@pytest.mark.parametrize(
-    ("trigger_key"),
-    ["zone.occupancy_detected", "zone.occupancy_cleared"],
-)
-async def test_zone_occupancy_trigger_options_validation(
-    hass: HomeAssistant,
-    trigger_key: str,
-) -> None:
-    """Test that occupancy triggers support the expected options."""
-    await assert_trigger_options_supported(
-        hass,
-        trigger_key,
-        {"zone": ZONE_HOME},
-        supports_behavior=False,
-        supports_duration=True,
-        supports_target=False,
-    )
-
-
-@pytest.mark.usefixtures("enable_labs_preview_features")
-@pytest.mark.parametrize(
-    ("trigger_key", "from_state", "to_state", "should_fire"),
-    [
-        # occupancy_detected
-        pytest.param("zone.occupancy_detected", "0", "1", True, id="detected_0_to_1"),
-        pytest.param("zone.occupancy_detected", "0", "3", True, id="detected_0_to_3"),
-        pytest.param("zone.occupancy_detected", "1", "2", False, id="detected_1_to_2"),
-        pytest.param("zone.occupancy_detected", "2", "0", False, id="detected_2_to_0"),
-        pytest.param(
-            "zone.occupancy_detected",
-            STATE_UNKNOWN,
-            "1",
-            False,
-            id="detected_unknown_to_1",
-        ),
-        pytest.param(
-            "zone.occupancy_detected",
-            STATE_UNAVAILABLE,
-            "1",
-            False,
-            id="detected_unavailable_to_1",
-        ),
-        pytest.param(
-            "zone.occupancy_detected",
-            "0",
-            STATE_UNAVAILABLE,
-            False,
-            id="detected_0_to_unavailable",
-        ),
-        # occupancy_cleared
-        pytest.param("zone.occupancy_cleared", "1", "0", True, id="cleared_1_to_0"),
-        pytest.param("zone.occupancy_cleared", "3", "0", True, id="cleared_3_to_0"),
-        pytest.param("zone.occupancy_cleared", "2", "1", False, id="cleared_2_to_1"),
-        pytest.param("zone.occupancy_cleared", "0", "1", False, id="cleared_0_to_1"),
-        pytest.param(
-            "zone.occupancy_cleared",
-            "1",
-            STATE_UNAVAILABLE,
-            False,
-            id="cleared_1_to_unavailable",
-        ),
-        pytest.param(
-            "zone.occupancy_cleared",
-            "1",
-            STATE_UNKNOWN,
-            False,
-            id="cleared_1_to_unknown",
-        ),
-    ],
-)
-async def test_zone_occupancy_trigger_transitions(
-    hass: HomeAssistant,
-    service_calls: list[ServiceCall],
-    trigger_key: str,
-    from_state: str,
-    to_state: str,
-    should_fire: bool,
-) -> None:
-    """Test occupancy triggers fire on the expected numeric-state transitions."""
-    hass.states.async_set(ZONE_HOME, from_state)
-    await hass.async_block_till_done()
-
-    assert await async_setup_component(
-        hass,
-        automation.DOMAIN,
-        {
-            automation.DOMAIN: {
-                "trigger": {
-                    "trigger": trigger_key,
-                    "options": {"zone": ZONE_HOME},
-                },
-                "action": {"service": "test.automation"},
-            }
-        },
-    )
-
-    hass.states.async_set(ZONE_HOME, to_state)
-    await hass.async_block_till_done()
-    assert (len(service_calls) == 1) is should_fire
-
-
-@pytest.mark.usefixtures("enable_labs_preview_features")
-@pytest.mark.parametrize(
-    ("trigger_key", "from_value", "to_value", "revert_value"),
-    [
-        ("zone.occupancy_detected", "0", "1", "0"),
-        ("zone.occupancy_cleared", "1", "0", "1"),
-    ],
-)
-async def test_zone_occupancy_trigger_for_duration(
-    hass: HomeAssistant,
-    freezer: FrozenDateTimeFactory,
-    service_calls: list[ServiceCall],
-    trigger_key: str,
-    from_value: str,
-    to_value: str,
-    revert_value: str,
-) -> None:
-    """Test that `for` delays the firing and an early revert cancels it."""
-    hass.states.async_set(ZONE_HOME, from_value)
-    await hass.async_block_till_done()
-
-    assert await async_setup_component(
-        hass,
-        automation.DOMAIN,
-        {
-            automation.DOMAIN: {
-                "trigger": {
-                    "trigger": trigger_key,
-                    "options": {"zone": ZONE_HOME, "for": {"seconds": 5}},
-                },
-                "action": {"service": "test.automation"},
-            }
-        },
-    )
-
-    # Transition, then revert before the duration elapses -> no fire.
-    hass.states.async_set(ZONE_HOME, to_value)
-    await hass.async_block_till_done()
-    hass.states.async_set(ZONE_HOME, revert_value)
-    await hass.async_block_till_done()
-    freezer.tick(timedelta(seconds=10))
-    async_fire_time_changed(hass)
-    await hass.async_block_till_done()
-    assert len(service_calls) == 0
-
-    # Transition and hold past the duration -> fire once.
-    hass.states.async_set(ZONE_HOME, to_value)
-    await hass.async_block_till_done()
-    freezer.tick(timedelta(seconds=10))
-    async_fire_time_changed(hass)
-    await hass.async_block_till_done()
-    assert len(service_calls) == 1
-
-
-@pytest.mark.usefixtures("enable_labs_preview_features")
-async def test_zone_occupancy_trigger_payload(
-    hass: HomeAssistant, service_calls: list[ServiceCall]
-) -> None:
-    """Test the payload exposed to the action template."""
-    hass.states.async_set(ZONE_HOME, "0")
-    await hass.async_block_till_done()
-
-    assert await async_setup_component(
-        hass,
-        automation.DOMAIN,
-        {
-            automation.DOMAIN: {
-                "trigger": {
-                    "trigger": "zone.occupancy_detected",
-                    "options": {"zone": ZONE_HOME},
-                },
-                "action": {
-                    "service": "test.automation",
-                    "data_template": {
-                        "some": (
-                            "{{ trigger.entity_id }}"
-                            " - {{ trigger.from_state.state }}"
-                            " - {{ trigger.to_state.state }}"
-                            " - {{ trigger.for }}"
-                        )
-                    },
-                },
-            }
-        },
-    )
-
-    hass.states.async_set(ZONE_HOME, "2")
-    await hass.async_block_till_done()
-
-    assert len(service_calls) == 1
-    assert service_calls[0].data["some"] == f"{ZONE_HOME} - 0 - 2 - None"

tests/helpers/test_trigger.py

@@ -4639,33 +4639,13 @@ async def test_entity_trigger_duration_cancelled_on_invalid_state(
         pytest.param(
             {
                 "platform": "zone",
-                "options": {
-                    "entity_id": ["person.a"],
-                    "zone": "zone.home",
-                    "event": "enter",
-                },
+                "entity_id": ["person.a"],
+                "zone": "zone.home",
+                "event": "enter",
             },
             ["person.a", "zone.home"],
             id="zone-legacy",
         ),
-        pytest.param(
-            {
-                "platform": "zone.entered",
-                "target": {"entity_id": ["person.a", "device_tracker.b"]},
-                "options": {"zone": "zone.home"},
-            },
-            ["person.a", "device_tracker.b", "zone.home"],
-            id="zone-entered-modern",
-        ),
-        pytest.param(
-            {
-                "platform": "zone.left",
-                "target": {"entity_id": "person.a"},
-                "options": {"zone": "zone.home"},
-            },
-            ["person.a", "zone.home"],
-            id="zone-left-modern",
-        ),
         pytest.param(
             {"platform": "geo_location", "zone": "zone.home"},
             ["zone.home"],