homeassistant 2025.9.4__py3-none-any.whl → 2025.10.0b1__py3-none-any.whl

homeassistant/components/uptimerobot/translations/zh-Hant.json

@@ -4,6 +4,7 @@
             "already_configured": "\u5e33\u865f\u5df2\u7d93\u8a2d\u5b9a\u5b8c\u6210",
             "reauth_failed_existing": "\u7121\u6cd5\u66f4\u65b0\u8a2d\u5b9a\u689d\u76ee\uff0c\u8acb\u79fb\u9664\u6574\u5408\u4e26\u91cd\u65b0\u8a2d\u5b9a\u3002",
             "reauth_successful": "\u91cd\u65b0\u8a8d\u8b49\u6210\u529f",
+            "reconfigure_successful": "\u91cd\u65b0\u8a2d\u5b9a\u6210\u529f",
             "unknown": "\u672a\u9810\u671f\u932f\u8aa4"
         },
         "error": {
@@ -23,6 +24,14 @@
                 },
                 "title": "{name} \u8a8d\u8b49\u5df2\u904e\u671f"
             },
+            "reconfigure": {
+                "data": {
+                    "api_key": "API \u91d1\u9470"
+                },
+                "data_description": {
+                    "api_key": "UptimeRobot \u5e33\u865f\u7684 'main' API \u5bc6\u9470"
+                }
+            },
             "user": {
                 "data": {
                     "api_key": "API \u91d1\u9470"

homeassistant/components/usage_prediction/__init__.py

@@ -0,0 +1,89 @@
+"""The usage prediction integration."""
+
+from __future__ import annotations
+
+import asyncio
+from datetime import timedelta
+from typing import Any
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+from homeassistant.util import dt as dt_util
+
+from . import common_control
+from .const import DATA_CACHE, DOMAIN
+from .models import EntityUsageDataCache, EntityUsagePredictions
+
+CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
+
+CACHE_DURATION = timedelta(hours=24)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the usage prediction integration."""
+    websocket_api.async_register_command(hass, ws_common_control)
+    hass.data[DATA_CACHE] = {}
+    return True
+
+
+@websocket_api.websocket_command({"type": f"{DOMAIN}/common_control"})
+@websocket_api.async_response
+async def ws_common_control(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Handle usage prediction common control WebSocket API."""
+    result = await get_cached_common_control(hass, connection.user.id)
+    time_category = common_control.time_category(dt_util.now().hour)
+    connection.send_result(
+        msg["id"],
+        {
+            "entities": getattr(result, time_category),
+        },
+    )
+
+
+async def get_cached_common_control(
+    hass: HomeAssistant, user_id: str
+) -> EntityUsagePredictions:
+    """Get cached common control predictions or fetch new ones.
+
+    Returns cached data if it's less than 24 hours old,
+    otherwise fetches new data and caches it.
+    """
+    # Create a unique storage key for this user
+    storage_key = user_id
+
+    cached_data = hass.data[DATA_CACHE].get(storage_key)
+
+    if isinstance(cached_data, asyncio.Task):
+        # If there's an ongoing task to fetch data, await its result
+        return await cached_data
+
+    # Check if cache is valid (less than 24 hours old)
+    if cached_data is not None:
+        if (dt_util.utcnow() - cached_data.timestamp) < CACHE_DURATION:
+            # Cache is still valid, return the cached predictions
+            return cached_data.predictions
+
+    # Create task fetching data
+    task = hass.async_create_task(
+        common_control.async_predict_common_control(hass, user_id)
+    )
+    hass.data[DATA_CACHE][storage_key] = task
+
+    try:
+        predictions = await task
+    except Exception:
+        # If the task fails, remove it from cache to allow retries
+        hass.data[DATA_CACHE].pop(storage_key)
+        raise
+
+    hass.data[DATA_CACHE][storage_key] = EntityUsageDataCache(
+        predictions=predictions,
+    )
+
+    return predictions

homeassistant/components/usage_prediction/common_control.py

@@ -0,0 +1,236 @@
+"""Code to generate common control usage patterns."""
+
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Callable, Sequence
+from datetime import datetime, timedelta
+from functools import cache
+import logging
+from typing import Any, Literal, cast
+
+from sqlalchemy import select
+from sqlalchemy.engine.row import Row
+from sqlalchemy.orm import Session
+
+from homeassistant.components.recorder import get_instance
+from homeassistant.components.recorder.db_schema import EventData, Events, EventTypes
+from homeassistant.components.recorder.models import uuid_hex_to_bytes_or_none
+from homeassistant.components.recorder.util import session_scope
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
+from homeassistant.util import dt as dt_util
+from homeassistant.util.json import json_loads_object
+
+from .models import EntityUsagePredictions
+
+_LOGGER = logging.getLogger(__name__)
+
+# Time categories for usage patterns
+TIME_CATEGORIES = ["morning", "afternoon", "evening", "night"]
+
+RESULTS_TO_INCLUDE = 8
+
+# List of domains for which we want to track usage
+ALLOWED_DOMAINS = {
+    # Entity platforms
+    Platform.AIR_QUALITY,
+    Platform.ALARM_CONTROL_PANEL,
+    Platform.BINARY_SENSOR,
+    Platform.BUTTON,
+    Platform.CAMERA,
+    Platform.CLIMATE,
+    Platform.COVER,
+    Platform.FAN,
+    Platform.HUMIDIFIER,
+    Platform.LAWN_MOWER,
+    Platform.LIGHT,
+    Platform.LOCK,
+    Platform.MEDIA_PLAYER,
+    Platform.NUMBER,
+    Platform.SCENE,
+    Platform.SELECT,
+    Platform.SENSOR,
+    Platform.SIREN,
+    Platform.SWITCH,
+    Platform.VACUUM,
+    Platform.VALVE,
+    Platform.WATER_HEATER,
+    # Helpers with own domain
+    "counter",
+    "group",
+    "input_boolean",
+    "input_button",
+    "input_datetime",
+    "input_number",
+    "input_select",
+    "input_text",
+    "schedule",
+    "timer",
+}
+
+
+@cache
+def time_category(hour: int) -> Literal["morning", "afternoon", "evening", "night"]:
+    """Determine the time category for a given hour."""
+    if 6 <= hour < 12:
+        return "morning"
+    if 12 <= hour < 18:
+        return "afternoon"
+    if 18 <= hour < 22:
+        return "evening"
+    return "night"
+
+
+async def async_predict_common_control(
+    hass: HomeAssistant, user_id: str
+) -> EntityUsagePredictions:
+    """Generate a list of commonly used entities for a user.
+
+    Args:
+        hass: Home Assistant instance
+        user_id: User ID to filter events by.
+    """
+    # Get the recorder instance to ensure it's ready
+    recorder = get_instance(hass)
+    ent_reg = er.async_get(hass)
+
+    # Execute the database operation in the recorder's executor
+    data = await recorder.async_add_executor_job(
+        _fetch_with_session, hass, _fetch_and_process_data, ent_reg, user_id
+    )
+    # Prepare a dictionary to track results
+    results: dict[str, Counter[str]] = {
+        time_cat: Counter() for time_cat in TIME_CATEGORIES
+    }
+
+    allowed_entities = set(hass.states.async_entity_ids(ALLOWED_DOMAINS))
+    hidden_entities: set[str] = set()
+
+    # Keep track of contexts that we processed so that we will only process
+    # the first service call in a context, and not subsequent calls.
+    context_processed: set[bytes] = set()
+    # Execute the query
+    context_id: bytes
+    time_fired_ts: float
+    shared_data: str | None
+    local_time_zone = dt_util.get_default_time_zone()
+    for context_id, time_fired_ts, shared_data in data:
+        # Skip if we have already processed an event that was part of this context
+        if context_id in context_processed:
+            continue
+
+        # Mark this context as processed
+        context_processed.add(context_id)
+
+        # Parse the event data
+        if not time_fired_ts or not shared_data:
+            continue
+
+        try:
+            event_data = json_loads_object(shared_data)
+        except (ValueError, TypeError) as err:
+            _LOGGER.debug("Failed to parse event data: %s", err)
+            continue
+
+        # Empty event data, skipping
+        if not event_data:
+            continue
+
+        service_data = cast(dict[str, Any] | None, event_data.get("service_data"))
+
+        # No service data found, skipping
+        if not service_data:
+            continue
+
+        entity_ids: str | list[str] | None
+        if (target := service_data.get("target")) and (
+            target_entity_ids := target.get("entity_id")
+        ):
+            entity_ids = target_entity_ids
+        else:
+            entity_ids = service_data.get("entity_id")
+
+        # No entity IDs found, skip this event
+        if entity_ids is None:
+            continue
+
+        if not isinstance(entity_ids, list):
+            entity_ids = [entity_ids]
+
+        # Convert to local time for time category determination
+        period = time_category(
+            datetime.fromtimestamp(time_fired_ts, local_time_zone).hour
+        )
+        period_results = results[period]
+
+        # Count entity usage
+        for entity_id in entity_ids:
+            if entity_id not in allowed_entities or entity_id in hidden_entities:
+                continue
+
+            if (
+                entity_id not in period_results
+                and (entry := ent_reg.async_get(entity_id))
+                and entry.hidden
+            ):
+                hidden_entities.add(entity_id)
+                continue
+
+            period_results[entity_id] += 1
+
+    return EntityUsagePredictions(
+        morning=[
+            ent_id for (ent_id, _) in results["morning"].most_common(RESULTS_TO_INCLUDE)
+        ],
+        afternoon=[
+            ent_id
+            for (ent_id, _) in results["afternoon"].most_common(RESULTS_TO_INCLUDE)
+        ],
+        evening=[
+            ent_id for (ent_id, _) in results["evening"].most_common(RESULTS_TO_INCLUDE)
+        ],
+        night=[
+            ent_id for (ent_id, _) in results["night"].most_common(RESULTS_TO_INCLUDE)
+        ],
+    )
+
+
+def _fetch_and_process_data(
+    session: Session, ent_reg: er.EntityRegistry, user_id: str
+) -> Sequence[Row[tuple[bytes | None, float | None, str | None]]]:
+    """Fetch and process service call events from the database."""
+    thirty_days_ago_ts = (dt_util.utcnow() - timedelta(days=30)).timestamp()
+    user_id_bytes = uuid_hex_to_bytes_or_none(user_id)
+    if not user_id_bytes:
+        raise ValueError("Invalid user_id format")
+
+    # Build the main query for events with their data
+    query = (
+        select(
+            Events.context_id_bin,
+            Events.time_fired_ts,
+            EventData.shared_data,
+        )
+        .select_from(Events)
+        .outerjoin(EventData, Events.data_id == EventData.data_id)
+        .outerjoin(EventTypes, Events.event_type_id == EventTypes.event_type_id)
+        .where(Events.time_fired_ts >= thirty_days_ago_ts)
+        .where(Events.context_user_id_bin == user_id_bytes)
+        .where(EventTypes.event_type == "call_service")
+        .order_by(Events.time_fired_ts)
+    )
+    return session.connection().execute(query).all()
+
+
+def _fetch_with_session(
+    hass: HomeAssistant,
+    fetch_func: Callable[
+        [Session], Sequence[Row[tuple[bytes | None, float | None, str | None]]]
+    ],
+    *args: object,
+) -> Sequence[Row[tuple[bytes | None, float | None, str | None]]]:
+    """Execute a fetch function with a database session."""
+    with session_scope(hass=hass, read_only=True) as session:
+        return fetch_func(session, *args)

homeassistant/components/usage_prediction/const.py

@@ -0,0 +1,13 @@
+"""Constants for the usage prediction integration."""
+
+import asyncio
+
+from homeassistant.util.hass_dict import HassKey
+
+from .models import EntityUsageDataCache, EntityUsagePredictions
+
+DOMAIN = "usage_prediction"
+
+DATA_CACHE: HassKey[
+    dict[str, asyncio.Task[EntityUsagePredictions] | EntityUsageDataCache]
+] = HassKey("usage_prediction")

homeassistant/components/usage_prediction/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "usage_prediction",
+  "name": "Usage Prediction",
+  "codeowners": ["@home-assistant/core"],
+  "dependencies": ["http", "recorder"],
+  "documentation": "https://www.home-assistant.io/integrations/usage_prediction",
+  "integration_type": "system",
+  "iot_class": "calculated",
+  "quality_scale": "internal"
+}

homeassistant/components/usage_prediction/models.py

@@ -0,0 +1,24 @@
+"""Models for the usage prediction integration."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+
+from homeassistant.util import dt as dt_util
+
+
+@dataclass
+class EntityUsagePredictions:
+    """Prediction which entities are likely to be used in each time category."""
+
+    morning: list[str] = field(default_factory=list)
+    afternoon: list[str] = field(default_factory=list)
+    evening: list[str] = field(default_factory=list)
+    night: list[str] = field(default_factory=list)
+
+
+@dataclass
+class EntityUsageDataCache:
+    """Data model for entity usage prediction."""
+
+    predictions: EntityUsagePredictions
+    timestamp: datetime = field(default_factory=dt_util.utcnow)

homeassistant/components/usage_prediction/strings.json

@@ -0,0 +1,3 @@
+{
+  "title": "Usage Prediction"
+}

homeassistant/components/usage_prediction/translations/cs.json

@@ -0,0 +1,3 @@
+{
+    "title": "P\u0159edpov\u011b\u010f pou\u017e\u00edv\u00e1n\u00ed"
+}

homeassistant/components/usage_prediction/translations/de.json

@@ -0,0 +1,3 @@
+{
+    "title": "Nutzungsprognose"
+}

homeassistant/components/usage_prediction/translations/en-GB.json

@@ -0,0 +1,3 @@
+{
+    "title": "Usage Prediction"
+}

homeassistant/components/usage_prediction/translations/en.json

@@ -0,0 +1,3 @@
+{
+    "title": "Usage Prediction"
+}

homeassistant/components/usage_prediction/translations/es.json

@@ -0,0 +1,3 @@
+{
+    "title": "Predicci\u00f3n de uso"
+}

homeassistant/components/usage_prediction/translations/ga.json

@@ -0,0 +1,3 @@
+{
+    "title": "R\u00e9amhaisn\u00e9is \u00das\u00e1ide"
+}

homeassistant/components/usage_prediction/translations/lt.json

@@ -0,0 +1,3 @@
+{
+    "title": "Naudojimo prognozavimas"
+}

homeassistant/components/usage_prediction/translations/pt.json

@@ -0,0 +1,3 @@
+{
+    "title": "Previs\u00e3o de utiliza\u00e7\u00e3o"
+}

homeassistant/components/usage_prediction/translations/sk.json

@@ -0,0 +1,3 @@
+{
+    "title": "Predpove\u010f pou\u017e\u00edvania"
+}

homeassistant/components/usage_prediction/translations/zh-Hans.json

@@ -0,0 +1,3 @@
+{
+    "title": "\u4f7f\u7528\u60c5\u51b5\u9884\u6d4b"
+}

homeassistant/components/usage_prediction/translations/zh-Hant.json

@@ -0,0 +1,3 @@
+{
+    "title": "\u4f7f\u7528\u91cf\u9810\u6e2c"
+}

homeassistant/components/vacuum/intent.py

@@ -3,7 +3,7 @@
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import intent
 
-from . import DOMAIN, SERVICE_RETURN_TO_BASE, SERVICE_START
+from . import DOMAIN, SERVICE_RETURN_TO_BASE, SERVICE_START, VacuumEntityFeature
 
 INTENT_VACUUM_START = "HassVacuumStart"
 INTENT_VACUUM_RETURN_TO_BASE = "HassVacuumReturnToBase"
@@ -20,6 +20,7 @@ async def async_setup_intents(hass: HomeAssistant) -> None:
             description="Starts a vacuum",
             required_domains={DOMAIN},
             platforms={DOMAIN},
+            required_features=VacuumEntityFeature.START,
         ),
     )
     intent.async_register(
@@ -31,5 +32,6 @@ async def async_setup_intents(hass: HomeAssistant) -> None:
             description="Returns a vacuum to base",
             required_domains={DOMAIN},
             platforms={DOMAIN},
+            required_features=VacuumEntityFeature.RETURN_HOME,
         ),
     )

homeassistant/components/verisure/alarm_control_panel.py

@@ -67,8 +67,13 @@ class VerisureAlarm(
         )
         LOGGER.debug("Verisure set arm state %s", state)
         result = None
+        attempts = 0
         while result is None:
-            await asyncio.sleep(0.5)
+            if attempts == 30:
+                break
+            if attempts > 1:
+                await asyncio.sleep(0.5)
+            attempts += 1
             transaction = await self.hass.async_add_executor_job(
                 self.coordinator.verisure.request,
                 self.coordinator.verisure.poll_arm_state(
@@ -81,8 +86,10 @@ class VerisureAlarm(
                 .get("armStateChangePollResult", {})
                 .get("result")
             )
-
-        await self.coordinator.async_refresh()
+            LOGGER.debug("Result is %s", result)
+        if result == "OK":
+            self._attr_alarm_state = ALARM_STATE_TO_HA.get(state)
+            self.async_write_ha_state()
 
     async def async_alarm_disarm(self, code: str | None = None) -> None:
         """Send disarm command."""
@@ -108,16 +115,20 @@ class VerisureAlarm(
             "ARMED_AWAY", self.coordinator.verisure.arm_away(code)
         )
 
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
+    def _update_alarm_attributes(self) -> None:
+        """Update alarm state and changed by from coordinator data."""
         self._attr_alarm_state = ALARM_STATE_TO_HA.get(
             self.coordinator.data["alarm"]["statusType"]
         )
         self._attr_changed_by = self.coordinator.data["alarm"].get("name")
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._update_alarm_attributes()
         super()._handle_coordinator_update()
 
     async def async_added_to_hass(self) -> None:
         """When entity is added to hass."""
         await super().async_added_to_hass()
-        self._handle_coordinator_update()
+        self._update_alarm_attributes()

homeassistant/components/verisure/lock.py

@@ -10,7 +10,7 @@ from verisure import Error as VerisureError
 from homeassistant.components.lock import LockEntity, LockState
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_CODE
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
@@ -70,7 +70,9 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
         self._attr_unique_id = serial_number
 
         self.serial_number = serial_number
-        self._state: str | None = None
+        self._attr_is_locked = None
+        self._attr_changed_by = None
+        self._changed_method: str | None = None
 
     @property
     def device_info(self) -> DeviceInfo:
@@ -92,20 +94,6 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
             super().available and self.serial_number in self.coordinator.data["locks"]
         )
 
-    @property
-    def changed_by(self) -> str | None:
-        """Last change triggered by."""
-        return (
-            self.coordinator.data["locks"][self.serial_number]
-            .get("user", {})
-            .get("name")
-        )
-
-    @property
-    def changed_method(self) -> str:
-        """Last change method."""
-        return self.coordinator.data["locks"][self.serial_number]["lockMethod"]
-
     @property
     def code_format(self) -> str:
         """Return the configured code format."""
@@ -115,16 +103,9 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
         return f"^\\d{{{digits}}}$"
 
     @property
-    def is_locked(self) -> bool:
-        """Return true if lock is locked."""
-        return (
-            self.coordinator.data["locks"][self.serial_number]["lockStatus"] == "LOCKED"
-        )
-
-    @property
-    def extra_state_attributes(self) -> dict[str, str]:
+    def extra_state_attributes(self) -> dict[str, str | None]:
         """Return the state attributes."""
-        return {"method": self.changed_method}
+        return {"method": self._changed_method}
 
     async def async_unlock(self, **kwargs: Any) -> None:
         """Send unlock command."""
@@ -154,7 +135,7 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
         target_state = "LOCKED" if state == LockState.LOCKED else "UNLOCKED"
         lock_status = None
         attempts = 0
-        while lock_status != "OK":
+        while lock_status is None:
             if attempts == 30:
                 break
             if attempts > 1:
@@ -172,8 +153,10 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
                 .get("doorLockStateChangePollResult", {})
                 .get("result")
             )
+            LOGGER.debug("Lock status is %s", lock_status)
         if lock_status == "OK":
-            self._state = state
+            self._attr_is_locked = state == LockState.LOCKED
+            self.async_write_ha_state()
 
     def disable_autolock(self) -> None:
         """Disable autolock on a doorlock."""
@@ -196,3 +179,21 @@ class VerisureDoorlock(CoordinatorEntity[VerisureDataUpdateCoordinator], LockEnt
             LOGGER.debug("Enabling autolock on %s", self.serial_number)
         except VerisureError as ex:
             LOGGER.error("Could not enable autolock, %s", ex)
+
+    def _update_lock_attributes(self) -> None:
+        """Update lock state, changed by, and method from coordinator data."""
+        lock_data = self.coordinator.data["locks"][self.serial_number]
+        self._attr_is_locked = lock_data["lockStatus"] == "LOCKED"
+        self._attr_changed_by = lock_data.get("user", {}).get("name")
+        self._changed_method = lock_data["lockMethod"]
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._update_lock_attributes()
+        super()._handle_coordinator_update()
+
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to hass."""
+        await super().async_added_to_hass()
+        self._update_lock_attributes()

homeassistant/components/verisure/switch.py

@@ -99,4 +99,4 @@ class VerisureSmartplug(CoordinatorEntity[VerisureDataUpdateCoordinator], Switch
         )
         self._state = state
         self._change_timestamp = monotonic()
-        await self.coordinator.async_request_refresh()
+        self.async_write_ha_state()