ha-mcp-dev 8.7.0.dev3077__tar.gz → 8.7.0.dev3080__tar.gz

{ha_mcp_dev-8.7.0.dev3077 → ha_mcp_dev-8.7.0.dev3080}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 8.7.0.dev3077
+Version: 8.7.0.dev3080
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-8.7.0.dev3077 → ha_mcp_dev-8.7.0.dev3080}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.7.0.dev3077"
+version = "8.7.0.dev3080"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.15"

{ha_mcp_dev-8.7.0.dev3077 → ha_mcp_dev-8.7.0.dev3080}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "8.7.0.dev3077"
+version = "8.7.0.dev3080"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

ha_mcp_dev-8.7.0.dev3080/src/ha_mcp/tools/history_response.py

@@ -0,0 +1,159 @@
+"""Present recorder history with readable names, local event times and per-state totals."""
+
+from datetime import UTC, datetime, tzinfo
+from typing import Any
+
+from .response_helpers import resolve_local_timezone
+
+_FIELD_NAMES = {
+    "s": "state",
+    "a": "attributes",
+    "lu": "last_updated",
+    "lc": "last_changed",
+}
+
+
+def _local_timestamp(value: Any, timezone: tzinfo) -> Any:
+    """Format supported Core event times without discarding unfamiliar values."""
+    try:
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            parsed = datetime.fromtimestamp(value, UTC)
+        elif isinstance(value, str):
+            parsed = datetime.fromisoformat(value)
+            if parsed.tzinfo is None:
+                parsed = parsed.replace(tzinfo=UTC)
+        else:
+            return value
+        return parsed.astimezone(timezone).isoformat()
+    except (ValueError, OverflowError, OSError):
+        return value
+
+
+def _readable_row(row: dict[str, Any], timezone: tzinfo) -> dict[str, Any]:
+    """Expand known compact keys once; retain unknown fields and name collisions."""
+    result = {}
+    for key, value in row.items():
+        name = _FIELD_NAMES.get(key, key)
+        if name in row:
+            result[key] = value
+        else:
+            result[name] = (
+                _local_timestamp(value, timezone) if key in {"lu", "lc"} else value
+            )
+    # Match Core's fallback; omitted lc does not prove a state change at lu.
+    if "lc" not in row and "last_changed" not in row and "lu" in row:
+        result["last_changed"] = _local_timestamp(row["lu"], timezone)
+    return result
+
+
+def format_history_response(response: dict[str, Any]) -> dict[str, Any]:
+    """Localize only history event times, leaving attributes and query bounds intact."""
+    if response["data"].get("source") != "history":
+        return response
+    metadata = response["metadata"]
+    timezone, name = resolve_local_timezone(
+        metadata.get("home_assistant_timezone", "UTC")
+    )
+    for entity in response["data"].get("entities", []):
+        if totals := entity.get("summary"):
+            for key in ("first_change", "last_change"):
+                totals[key] = _local_timestamp(totals[key], timezone)
+            continue
+        entity["states"] = [_readable_row(row, timezone) for row in entity["states"]]
+    metadata.update(
+        home_assistant_timezone=name,
+        timestamp_format=f"ISO 8601 ({name})",
+        note=(
+            f"History event times use {name}. When Core omits lc, last_changed "
+            "falls back to last_updated; it may not be the actual state-change time "
+            "with significant_changes_only or a window-start snapshot. "
+            "Attributes, unknown fields and query bounds are unchanged."
+            " UTC is used if HA's timezone is unavailable."
+        ),
+    )
+    return response
+
+
+def summarize_states(
+    states: list[dict[str, Any]],
+    window_start_ts: float,
+    window_end_ts: float,
+    limit: int,
+) -> dict[str, Any]:
+    """Reduce Core's oldest-first compressed rows to periods and seconds per state.
+
+    Each row lasts until the next row's ``lu`` and the last one until the window
+    end; rows after the window end must be dropped first. A row repeating the
+    previous state (an attribute-only update, which Core may return) extends
+    the current period instead of opening one. Core stamps its window-start
+    snapshot with the window start, so the first row counts as a change only
+    when it is later than the window start.
+    """
+    totals: dict[str, dict[str, Any]] = {}
+    change_times: list[float] = []
+    bounds = [row["lu"] for row in states] + [window_end_ts]
+    for index, row in enumerate(states):
+        state = row["s"]
+        entry = totals.setdefault(state, {"periods": 0, "duration_s": 0.0})
+        if index == 0 or state != states[index - 1]["s"]:
+            entry["periods"] += 1
+            if index or row["lu"] > window_start_ts:
+                change_times.append(row["lu"])
+        entry["duration_s"] += bounds[index + 1] - bounds[index]
+    ranked = sorted(
+        totals.items(), key=lambda item: item[1]["duration_s"], reverse=True
+    )
+    return {
+        "changes": len(change_times),
+        "first_change": change_times[0] if change_times else None,
+        "last_change": change_times[-1] if change_times else None,
+        "distinct_states": len(totals),
+        "states": {
+            state: {
+                "periods": entry["periods"],
+                "duration_s": round(entry["duration_s"], 3),
+            }
+            for state, entry in ranked[:limit]
+        },
+    }
+
+
+def summary_warnings(
+    result: dict[str, list[dict[str, Any]]],
+    summaries: dict[str, dict[str, Any]],
+    window_start_ts: float,
+) -> list[str]:
+    """Name the entities whose totals cover less than the requested window or list only some of their states."""
+    missing: list[str] = []
+    late: list[str] = []
+    cut: list[str] = []
+    for entity_id, summary in summaries.items():
+        states = result.get(entity_id)
+        if not states:
+            missing.append(entity_id)
+        elif states[0]["lu"] > window_start_ts:
+            late.append(entity_id)
+        if left_out := summary["distinct_states"] - len(summary["states"]):
+            cut.append(f"{entity_id}: {left_out} of {summary['distinct_states']}")
+    warnings = []
+    if missing:
+        warnings.append(
+            f"No recorded states for: {', '.join(missing)} in this window. Check "
+            "the entity IDs, the time range and that the recorder includes them; "
+            "their summaries count nothing."
+        )
+    if late:
+        warnings.append(
+            f"Totals for {', '.join(late)} start at the first recorded state, "
+            "after start_time: Core returned no earlier state (entity added "
+            "later, older history purged, or core_options "
+            "{'include_start_time_state': false})."
+        )
+    if cut:
+        warnings.append(
+            "limit left the shortest states out of summary.states, per entity: "
+            f"{', '.join(cut)}. A brief state such as unavailable may be among "
+            "them; raise limit (max 1000) or shorten the time range to list every "
+            "state."
+        )
+    return warnings

ha_mcp_dev-8.7.0.dev3080/src/ha_mcp/tools/statistics_calendar.py

@@ -0,0 +1,76 @@
+"""Estimate the calendar-aligned window Core scans for day, week, month and year statistics."""
+
+from datetime import UTC, datetime, timedelta, tzinfo
+
+_CALENDAR_STATISTICS_PERIODS = frozenset({"day", "week", "month", "year"})
+
+
+def _statistics_scan_window(
+    start_dt: datetime,
+    end_dt: datetime,
+    period: str,
+    local_timezone: tzinfo,
+) -> tuple[datetime, datetime]:
+    """Estimate Core's scan expansion for HA-MCP workload limits (not API validation)."""
+    if period not in _CALENDAR_STATISTICS_PERIODS:
+        return start_dt, end_dt
+
+    local_start = start_dt.astimezone(local_timezone)
+    local_end = end_dt.astimezone(local_timezone)
+
+    if period == "day":
+        scan_start = local_start.replace(hour=0, minute=0, second=0, microsecond=0)
+        scan_end = local_end.replace(
+            hour=0, minute=0, second=0, microsecond=0
+        ) + timedelta(days=1)
+    elif period == "week":
+        scan_start = local_start.replace(
+            hour=0, minute=0, second=0, microsecond=0
+        ) - timedelta(days=local_start.weekday())
+        scan_end = (
+            local_end.replace(hour=0, minute=0, second=0, microsecond=0)
+            - timedelta(days=local_end.weekday())
+            + timedelta(days=7)
+        )
+    elif period == "month":
+        scan_start = local_start.replace(
+            day=1, hour=0, minute=0, second=0, microsecond=0
+        )
+        scan_end = _next_month_start(local_end)
+    else:
+        scan_start = local_start.replace(
+            month=1, day=1, hour=0, minute=0, second=0, microsecond=0
+        )
+        scan_end = local_end.replace(
+            year=local_end.year + 1,
+            month=1,
+            day=1,
+            hour=0,
+            minute=0,
+            second=0,
+            microsecond=0,
+        )
+
+    return scan_start.astimezone(UTC), scan_end.astimezone(UTC)
+
+
+def _next_month_start(value: datetime) -> datetime:
+    """Return local midnight on the first day of the following month."""
+    if value.month == 12:
+        return value.replace(
+            year=value.year + 1,
+            month=1,
+            day=1,
+            hour=0,
+            minute=0,
+            second=0,
+            microsecond=0,
+        )
+    return value.replace(
+        month=value.month + 1,
+        day=1,
+        hour=0,
+        minute=0,
+        second=0,
+        microsecond=0,
+    )

{ha_mcp_dev-8.7.0.dev3077 → ha_mcp_dev-8.7.0.dev3080}/src/ha_mcp/tools/tools_history.py

@@ -32,7 +32,11 @@ from .helpers import (
     register_tool_methods,
     safe_progress,
 )
-from .history_response import format_history_response
+from .history_response import (
+    format_history_response,
+    summarize_states,
+    summary_warnings,
+)
 from .recorder_errors import raise_recorder_ws_failure as _raise_recorder_ws_failure
 from .response_helpers import (
     add_timezone_metadata,
@@ -41,6 +45,10 @@ from .response_helpers import (
     project_fields,
     resolve_local_timezone,
 )
+from .statistics_calendar import (
+    _CALENDAR_STATISTICS_PERIODS,
+    _statistics_scan_window,
+)
 from .statistics_helpers import (
     _parse_statistic_types,
     fetch_statistics_metadata,
@@ -124,7 +132,6 @@ _MAX_HISTORY_ENTITY_HOURS = 240.0
 _MAX_STATISTICS_ENTITIES = 25
 _MAX_SHORT_TERM_STATISTICS_ROWS = 10_000
 _MAX_LONG_TERM_STATISTICS_ROWS = 20_000
-_CALENDAR_STATISTICS_PERIODS = frozenset({"day", "week", "month", "year"})
 _VALID_STATISTICS_PERIODS = frozenset(
     {"5minute", "hour", *_CALENDAR_STATISTICS_PERIODS}
 )
@@ -254,7 +261,8 @@ class HistoryTools:
             int | None,
             Field(
                 description='Max entries per entity. Default: 100. For source="history": state '
-                'changes. For source="statistics": aggregated rows. With multiple '
+                "rows; with summary=True, the states listed in summary.states, longest "
+                'first. For source="statistics": aggregated rows. With multiple '
                 "entity_ids, total rows returned can reach limit × len(entity_ids).",
                 default=None,
                 ge=1,
@@ -296,6 +304,23 @@ class HistoryTools:
                 ),
             ),
         ] = "desc",
+        summary: Annotated[
+            bool,
+            Field(
+                default=False,
+                description=(
+                    "Return per-entity totals instead of state rows: changes "
+                    "(switches to a different state; the state at the window start is "
+                    "not one, but without that state, e.g. with core_options "
+                    "{'include_start_time_state': false} or purged history, the first "
+                    "recorded state counts as one), first_change and last_change (null "
+                    "without changes), and per state its periods (separate spells) and "
+                    "duration_s (seconds, up to end_time or now, whichever is "
+                    "earlier). distinct_states counts every state, listed or not. "
+                    'Ignored when source="statistics".'
+                ),
+            ),
+        ] = False,
         fields: Annotated[
             str | list[str] | None,
             JSON_STRING_COERCION,
@@ -333,8 +358,10 @@ class HistoryTools:
 
         WHEN TO USE:
         Use source="history" (default) to troubleshoot why a value changed, check
-        event sequences, or analyze recent patterns. Use source="statistics" for
-        long-term trends and period averages.
+        event sequences, or analyze recent patterns. Use summary=True when the
+        question needs a count or a duration ("was it ever unavailable?") rather
+        than the rows. Use source="statistics" for long-term trends and period
+        averages.
 
         CAVEATS:
         History rows rename Core's compact keys once: s -> state, a -> attributes,
@@ -354,6 +381,7 @@ class HistoryTools:
         All data is fetched from HA before slicing; limit/offset are client-side.
         With multiple entity_ids, offset must be 0 — use a single entity_id for
         offset > 0. Use has_more and next_offset from the response to paginate.
+        With source="history", summary=True does not combine with offset > 0.
         Administrators can optionally enable recorder workload guardrails in
         Advanced settings. When enabled, oversized entity/time workloads are
         rejected before the recorder query is issued; narrow the time range or
@@ -364,6 +392,7 @@ class HistoryTools:
         EXAMPLES:
         - ha_get_history(entity_ids="sensor.bedroom_temperature", start_time="24h")
         - Paginate oldest-first: ha_get_history(entity_ids="sensor.temperature", start_time="7d", limit=100, offset=100, order="asc")
+        - Time per state: ha_get_history(entity_ids="binary_sensor.door", start_time="7d", summary=True)
         - ha_get_history(source="statistics", entity_ids="sensor.living_room_temperature", start_time="6m", period="month", statistic_types=["mean", "min", "max"])
         """
         parsed_fields: list[str] | None = None
@@ -375,30 +404,18 @@ class HistoryTools:
             except ValueError as exc:
                 raise_tool_error(create_validation_error(str(exc), parameter="fields"))
         try:
-            # Parse entity_ids
             entity_id_list = _parse_entity_ids(entity_ids)
+            _validate_offset(
+                offset,
+                entity_count=len(entity_id_list),
+                summary=summary and source == "history",
+            )
 
-            # Offset > 0 is only supported for single-entity requests.
-            # build_pagination_metadata applies per entity — limit=100 across
-            # 5 entities returns up to 500 rows with no top-level has_more signal.
-            _effective_offset = offset if offset is not None else 0
-            if _effective_offset > 0 and len(entity_id_list) > 1:
-                raise_tool_error(
-                    create_error_response(
-                        ErrorCode.VALIDATION_INVALID_PARAMETER,
-                        "offset > 0 requires a single entity_id",
-                        context={"offset": offset, "entity_count": len(entity_id_list)},
-                        suggestions=[
-                            "Use a single entity_id when offset > 0, or use offset=0 for multi-entity requests."
-                        ],
-                    )
-                )
-
-            # Source-dependent default hours
             default_hours = _DEFAULT_START_HOURS_BY_SOURCE[source]
-
-            # Parse time parameters
-            start_dt, end_dt = _parse_time_range(start_time, end_time, default_hours)
+            now = datetime.now(UTC)
+            start_dt, end_dt = _parse_time_range(
+                start_time, end_time, default_hours, now
+            )
             query_settings = get_global_settings()
             statistics_timezone = await _prepare_guardrail_query(
                 self._client,
@@ -469,6 +486,7 @@ class HistoryTools:
                     _MAX_HISTORY_LIMIT,
                     order=order,
                     core_options=core_options,
+                    summary_until=min(end_dt, now) if summary else None,
                 )
             if include_schema:
                 command = (
@@ -569,6 +587,37 @@ def _parse_entity_ids(entity_ids: str | list[str]) -> list[str]:
     return entity_ids
 
 
+def _validate_offset(offset: int | None, *, entity_count: int, summary: bool) -> None:
+    """Reject offsets the response could not honour."""
+    if not offset:
+        return
+    # Summary first: dropping to one entity_id alone would still be rejected.
+    if summary:
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_INVALID_PARAMETER,
+                "summary=True covers the whole window and does not take an offset",
+                context={"offset": offset},
+                suggestions=[
+                    "Omit offset, or set summary=False to page through state rows."
+                ],
+            )
+        )
+    # build_pagination_metadata applies per entity — limit=100 across
+    # 5 entities returns up to 500 rows with no top-level has_more signal.
+    if entity_count > 1:
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_INVALID_PARAMETER,
+                "offset > 0 requires a single entity_id",
+                context={"offset": offset, "entity_count": entity_count},
+                suggestions=[
+                    "Use a single entity_id when offset > 0, or use offset=0 for multi-entity requests."
+                ],
+            )
+        )
+
+
 def _parse_time_range(
     start_time: str | None,
     end_time: str | None,
@@ -816,77 +865,6 @@ def _statistics_workload_violation(
     return context, suggestions
 
 
-def _statistics_scan_window(
-    start_dt: datetime,
-    end_dt: datetime,
-    period: str,
-    local_timezone: tzinfo,
-) -> tuple[datetime, datetime]:
-    """Estimate Core's scan expansion for HA-MCP workload limits (not API validation)."""
-    if period not in _CALENDAR_STATISTICS_PERIODS:
-        return start_dt, end_dt
-
-    local_start = start_dt.astimezone(local_timezone)
-    local_end = end_dt.astimezone(local_timezone)
-
-    if period == "day":
-        scan_start = local_start.replace(hour=0, minute=0, second=0, microsecond=0)
-        scan_end = local_end.replace(
-            hour=0, minute=0, second=0, microsecond=0
-        ) + timedelta(days=1)
-    elif period == "week":
-        scan_start = local_start.replace(
-            hour=0, minute=0, second=0, microsecond=0
-        ) - timedelta(days=local_start.weekday())
-        scan_end = (
-            local_end.replace(hour=0, minute=0, second=0, microsecond=0)
-            - timedelta(days=local_end.weekday())
-            + timedelta(days=7)
-        )
-    elif period == "month":
-        scan_start = local_start.replace(
-            day=1, hour=0, minute=0, second=0, microsecond=0
-        )
-        scan_end = _next_month_start(local_end)
-    else:
-        scan_start = local_start.replace(
-            month=1, day=1, hour=0, minute=0, second=0, microsecond=0
-        )
-        scan_end = local_end.replace(
-            year=local_end.year + 1,
-            month=1,
-            day=1,
-            hour=0,
-            minute=0,
-            second=0,
-            microsecond=0,
-        )
-
-    return scan_start.astimezone(UTC), scan_end.astimezone(UTC)
-
-
-def _next_month_start(value: datetime) -> datetime:
-    """Return local midnight on the first day of the following month."""
-    if value.month == 12:
-        return value.replace(
-            year=value.year + 1,
-            month=1,
-            day=1,
-            hour=0,
-            minute=0,
-            second=0,
-            microsecond=0,
-        )
-    return value.replace(
-        month=value.month + 1,
-        day=1,
-        hour=0,
-        minute=0,
-        second=0,
-        microsecond=0,
-    )
-
-
 async def _fetch_history(
     client: Any,
     entity_id_list: list[str],
@@ -900,11 +878,14 @@ async def _fetch_history(
     max_limit: int,
     order: str = "desc",
     core_options: dict[str, Any] | None = None,
+    summary_until: datetime | None = None,
 ) -> dict[str, Any]:
     """Execute the history/history_during_period WebSocket call.
 
     *order* controls state-list ordering: ``"desc"`` (default) returns the
-    newest states first; ``"asc"`` returns the oldest first.
+    newest states first; ``"asc"`` returns the oldest first. With
+    *summary_until*, each entity carries ``summarize_states`` totals up to that
+    time instead of its rows.
 
     Returns the unwrapped history dict; the caller is responsible for projection
     and wrapping with ``add_timezone_metadata``.
@@ -940,10 +921,30 @@ async def _fetch_history(
         )
 
     result_data = response.get("result", {})
+    if summary_until is not None:
+        # ha_get_history passes min(end_time, the clock it read before this
+        # query). Core answers a future end_time up to its own clock, which can
+        # run past that reading. Like Core's end_time, summary_until is exclusive.
+        until_ts = summary_until.timestamp()
+        result_data = {
+            entity_id: [row for row in rows if row["lu"] < until_ts]
+            for entity_id, rows in result_data.items()
+        }
     entities_history = []
+    summaries: dict[str, dict[str, Any]] = {}
+    start_ts = start_dt.timestamp()
+    period = {"start": start_dt.isoformat(), "end": end_dt.isoformat()}
 
     for entity_id in entity_id_list:
         entity_states = result_data.get(entity_id, [])
+        if summary_until is not None:
+            summary = summaries[entity_id] = summarize_states(
+                entity_states, start_ts, summary_until.timestamp(), effective_limit
+            )
+            entities_history.append(
+                {"entity_id": entity_id, "period": period, "summary": summary}
+            )
+            continue
         if order == "desc":
             entity_states = list(reversed(entity_states))
         paged_states = entity_states[
@@ -959,10 +960,7 @@ async def _fetch_history(
         entities_history.append(
             {
                 "entity_id": entity_id,
-                "period": {
-                    "start": start_dt.isoformat(),
-                    "end": end_dt.isoformat(),
-                },
+                "period": period,
                 "states": paged_states,
                 **pagination,
             }
@@ -972,18 +970,18 @@ async def _fetch_history(
         "success": True,
         "source": "history",
         "entities": entities_history,
-        "period": {
-            "start": start_dt.isoformat(),
-            "end": end_dt.isoformat(),
-        },
+        "period": period,
         "query_params": {
             "minimal_response": minimal_response,
             "significant_changes_only": significant_changes_only,
             "limit": effective_limit,
             "offset": effective_offset,
             "order": order,
+            "summary": summary_until is not None,
         },
     }
+    if summary_until is not None:  # ha_get_history drops an empty list
+        history_data["warnings"] = summary_warnings(result_data, summaries, start_ts)
 
     return history_data
 

ha_mcp_dev-8.7.0.dev3077/src/ha_mcp/tools/history_response.py

@@ -1,70 +0,0 @@
-"""Present recorder history with readable names and local event times."""
-
-from datetime import UTC, datetime, tzinfo
-from typing import Any
-
-from .response_helpers import resolve_local_timezone
-
-_FIELD_NAMES = {
-    "s": "state",
-    "a": "attributes",
-    "lu": "last_updated",
-    "lc": "last_changed",
-}
-
-
-def _local_timestamp(value: Any, timezone: tzinfo) -> Any:
-    """Format supported Core event times without discarding unfamiliar values."""
-    try:
-        if isinstance(value, (int, float)) and not isinstance(value, bool):
-            parsed = datetime.fromtimestamp(value, UTC)
-        elif isinstance(value, str):
-            parsed = datetime.fromisoformat(value)
-            if parsed.tzinfo is None:
-                parsed = parsed.replace(tzinfo=UTC)
-        else:
-            return value
-        return parsed.astimezone(timezone).isoformat()
-    except (ValueError, OverflowError, OSError):
-        return value
-
-
-def _readable_row(row: dict[str, Any], timezone: tzinfo) -> dict[str, Any]:
-    """Expand known compact keys once; retain unknown fields and name collisions."""
-    result = {}
-    for key, value in row.items():
-        name = _FIELD_NAMES.get(key, key)
-        if name in row:
-            result[key] = value
-        else:
-            result[name] = (
-                _local_timestamp(value, timezone) if key in {"lu", "lc"} else value
-            )
-    # Match Core's fallback; omitted lc does not prove a state change at lu.
-    if "lc" not in row and "last_changed" not in row and "lu" in row:
-        result["last_changed"] = _local_timestamp(row["lu"], timezone)
-    return result
-
-
-def format_history_response(response: dict[str, Any]) -> dict[str, Any]:
-    """Localize only history event times, leaving attributes and query bounds intact."""
-    if response["data"].get("source") != "history":
-        return response
-    metadata = response["metadata"]
-    timezone, name = resolve_local_timezone(
-        metadata.get("home_assistant_timezone", "UTC")
-    )
-    for entity in response["data"].get("entities", []):
-        entity["states"] = [_readable_row(row, timezone) for row in entity["states"]]
-    metadata.update(
-        home_assistant_timezone=name,
-        timestamp_format=f"ISO 8601 ({name})",
-        note=(
-            f"History event times use {name}. When Core omits lc, last_changed "
-            "falls back to last_updated; it may not be the actual state-change time "
-            "with significant_changes_only or a window-start snapshot. "
-            "Attributes, unknown fields and query bounds are unchanged."
-            " UTC is used if HA's timezone is unavailable."
-        ),
-    )
-    return response