[pull] dev from home-assistant:dev

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.78.0"]
+  "requirements": ["anthropic==0.83.0"]
 }

homeassistant/components/ecovacs/vacuum.py

@@ -8,17 +8,24 @@
 
 from deebot_client.capabilities import Capabilities, DeviceType
 from deebot_client.device import Device
-from deebot_client.events import FanSpeedEvent, RoomsEvent, StateEvent
-from deebot_client.models import CleanAction, CleanMode, Room, State
+from deebot_client.events import (
+    CachedMapInfoEvent,
+    FanSpeedEvent,
+    RoomsEvent,
+    StateEvent,
+)
+from deebot_client.events.map import Map
+from deebot_client.models import CleanAction, CleanMode, State
 import sucks
 
 from homeassistant.components.vacuum import (
+    Segment,
     StateVacuumEntity,
     StateVacuumEntityDescription,
     VacuumActivity,
     VacuumEntityFeature,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import slugify
@@ -29,6 +36,7 @@
 from .util import get_name_key
 
 _LOGGER = logging.getLogger(__name__)
+_SEGMENTS_SEPARATOR = "_"
 
 ATTR_ERROR = "error"
 
@@ -218,22 +226,22 @@ def __init__(self, device: Device) -> None:
         """Initialize the vacuum."""
         super().__init__(device, device.capabilities)
 
-        self._rooms: list[Room] = []
+        self._room_event: RoomsEvent | None = None
+        self._maps: dict[str, Map] = {}
 
         if fan_speed := self._capability.fan_speed:
             self._attr_supported_features |= VacuumEntityFeature.FAN_SPEED
             self._attr_fan_speed_list = [
                 get_name_key(level) for level in fan_speed.types
             ]
 
+        if self._capability.map and self._capability.clean.action.area:
+            self._attr_supported_features |= VacuumEntityFeature.CLEAN_AREA
+
     async def async_added_to_hass(self) -> None:
         """Set up the event listeners now that hass is ready."""
         await super().async_added_to_hass()
 
-        async def on_rooms(event: RoomsEvent) -> None:
-            self._rooms = event.rooms
-            self.async_write_ha_state()
-
         async def on_status(event: StateEvent) -> None:
             self._attr_activity = _STATE_TO_VACUUM_STATE[event.state]
             self.async_write_ha_state()
@@ -249,8 +257,20 @@ async def on_fan_speed(event: FanSpeedEvent) -> None:
             self._subscribe(self._capability.fan_speed.event, on_fan_speed)
 
         if map_caps := self._capability.map:
+
+            async def on_rooms(event: RoomsEvent) -> None:
+                self._room_event = event
+                self._check_segments_changed()
+                self.async_write_ha_state()
+
             self._subscribe(map_caps.rooms.event, on_rooms)
 
+            async def on_map_info(event: CachedMapInfoEvent) -> None:
+                self._maps = {map_obj.id: map_obj for map_obj in event.maps}
+                self._check_segments_changed()
+
+            self._subscribe(map_caps.cached_info.event, on_map_info)
+
     @property
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes.
@@ -259,7 +279,10 @@ def extra_state_attributes(self) -> Mapping[str, Any] | None:
         is lowercase snake_case.
         """
         rooms: dict[str, Any] = {}
-        for room in self._rooms:
+        if self._room_event is None:
+            return rooms
+
+        for room in self._room_event.rooms:
             # convert room name to snake_case to meet the convention
             room_name = slugify(room.name)
             room_values = rooms.get(room_name)
@@ -374,3 +397,116 @@ async def async_raw_get_positions(
             )
 
         return await self._device.execute_command(position_commands[0])
+
+    @callback
+    def _check_segments_changed(self) -> None:
+        """Check if segments have changed and create repair issue."""
+        last_seen = self.last_seen_segments
+        if last_seen is None:
+            return
+
+        last_seen_ids = {seg.id for seg in last_seen}
+        current_ids = {seg.id for seg in self._get_segments()}
+
+        if current_ids != last_seen_ids:
+            self.async_create_segments_issue()
+
+    def _get_segments(self) -> list[Segment]:
+        """Get the segments that can be cleaned."""
+        last_seen = self.last_seen_segments or []
+        if self._room_event is None or not self._maps:
+            # If we don't have the necessary information to determine segments, return the last
+            # seen segments to avoid temporarily losing all segments until we get the necessary
+            # information, which could cause unnecessary issues to be created
+            return last_seen
+
+        map_id = self._room_event.map_id
+        if (map_obj := self._maps.get(map_id)) is None:
+            _LOGGER.warning("Map ID %s not found in available maps", map_id)
+            return []
+
+        id_prefix = f"{map_id}{_SEGMENTS_SEPARATOR}"
+        other_map_ids = {
+            map_obj.id
+            for map_obj in self._maps.values()
+            if map_obj.id != self._room_event.map_id
+        }
+        # Include segments from the current map and any segments from other maps that were
+        # previously seen, as we want to continue showing segments from other maps for
+        # mapping purposes
+        segments = [
+            seg for seg in last_seen if _split_composite_id(seg.id)[0] in other_map_ids
+        ]
+        segments.extend(
+            Segment(
+                id=f"{id_prefix}{room.id}",
+                name=room.name,
+                group=map_obj.name,
+            )
+            for room in self._room_event.rooms
+        )
+        return segments
+
+    async def async_get_segments(self) -> list[Segment]:
+        """Get the segments that can be cleaned."""
+        return self._get_segments()
+
+    async def async_clean_segments(self, segment_ids: list[str], **kwargs: Any) -> None:
+        """Perform an area clean.
+
+        Only cleans segments from the currently selected map.
+        """
+        if not self._maps:
+            _LOGGER.warning("No map information available, cannot clean segments")
+            return
+
+        valid_room_ids: list[int | float] = []
+        for composite_id in segment_ids:
+            map_id, segment_id = _split_composite_id(composite_id)
+            if (map_obj := self._maps.get(map_id)) is None:
+                _LOGGER.warning("Map ID %s not found in available maps", map_id)
+                continue
+
+            if not map_obj.using:
+                room_name = next(
+                    (
+                        segment.name
+                        for segment in self.last_seen_segments or []
+                        if segment.id == composite_id
+                    ),
+                    "",
+                )
+                _LOGGER.warning(
+                    'Map "%s" is not currently selected, skipping segment "%s" (%s)',
+                    map_obj.name,
+                    room_name,
+                    segment_id,
+                )
+                continue
+
+            valid_room_ids.append(int(segment_id))
+
+        if not valid_room_ids:
+            _LOGGER.warning(
+                "No valid segments to clean after validation, skipping clean segments command"
+            )
+            return
+
+        if TYPE_CHECKING:
+            # Supported feature is only added if clean.action.area is not None
+            assert self._capability.clean.action.area is not None
+
+        await self._device.execute_command(
+            self._capability.clean.action.area(
+                CleanMode.SPOT_AREA,
+                valid_room_ids,
+                1,
+            )
+        )
+
+
+@callback
+def _split_composite_id(composite_id: str) -> tuple[str, str]:
+    """Split a composite ID into its components."""
+    map_id, _, segment_id = composite_id.partition(_SEGMENTS_SEPARATOR)
+    return map_id, segment_id

homeassistant/components/google_assistant/trait.py

@@ -1752,15 +1752,15 @@ def __init__(self, hass, state, config):
         """Initialize a trait for a state."""
         super().__init__(hass, state, config)
         if state.domain == fan.DOMAIN:
-            speed_count = min(
-                FAN_SPEED_MAX_SPEED_COUNT,
-                round(
-                    100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
-                ),
+            speed_count = round(
+                100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
             )
-            self._ordered_speed = [
-                f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
-            ]
+            if speed_count <= FAN_SPEED_MAX_SPEED_COUNT:
+                self._ordered_speed = [
+                    f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
+                ]
+            else:
+                self._ordered_speed = []
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -1786,7 +1786,11 @@ def sync_attributes(self) -> dict[str, Any]:
             result.update(
                 {
                     "reversible": reversible,
-                    "supportsFanSpeedPercent": True,
+                    # supportsFanSpeedPercent is mutually exclusive with
+                    # availableFanSpeeds, where supportsFanSpeedPercent takes
+                    # precedence. Report it only when step speeds are not
+                    # supported so Google renders a percent slider (1-100%).
+                    "supportsFanSpeedPercent": not self._ordered_speed,
                 }
             )
 
@@ -1832,10 +1836,12 @@ def query_attributes(self) -> dict[str, Any]:
 
         if domain == fan.DOMAIN:
             percent = attrs.get(fan.ATTR_PERCENTAGE) or 0
-            response["currentFanSpeedPercent"] = percent
-            response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
-                self._ordered_speed, percent
-            )
+            if self._ordered_speed:
+                response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
+                    self._ordered_speed, percent
+                )
+            else:
+                response["currentFanSpeedPercent"] = percent
 
         return response
 
@@ -1855,7 +1861,7 @@ async def execute_fanspeed(self, data, params):
             )
 
         if domain == fan.DOMAIN:
-            if fan_speed := params.get("fanSpeed"):
+            if self._ordered_speed and (fan_speed := params.get("fanSpeed")):
                 fan_speed_percent = ordered_list_item_to_percentage(
                     self._ordered_speed, fan_speed
                 )