fix(web): stop the /entity page reporting a status it never held (#4304)

The /entity page showed two GivEnergy Cloud inverters' status sensors
disagreeing with themselves: the timeline chart drew one continuous
"Normal" bar while the history table reported "Lost" for the same hours,
and a table row could report "Lost" while every 5-minute slot listed
under it read "Normal". Both views were wrong, in different ways.

History table (build_entity_history_table_data):

- A row reported the last sample taken inside its window rather than the
  state across it, so one momentary "Lost" record at 21:57 made the whole
  21:30 row read "Lost". Carry-forward then repeated that value into every
  later slot with no sample of its own, turning a blip into hours of
  apparent downtime. Every 30-minute row and 5-minute slot now reports the
  state as of its own timestamp - the most recent record at or before it -
  via a new state_as_of_slots() helper.

  Note this is the rule 7248a75 (#4291) established when it fixed buckets
  keeping the oldest sample instead of the newest; the bucket-summary idea
  itself was the problem.

- Detail rows were the offsets -5..-25, i.e. the half hour BEFORE the row,
  so expanding a row described a different window and contradicted the row
  it sat under. They are now the 5-minute marks inside the row's own window.

Timeline chart (render_timeline_chart):

- State records were downsampled by array index (every Nth, max 288) before
  being folded into ranges. For a categorical series that does not lower the
  resolution, it rewrites history: whenever the step kept landing on one
  phase of a flapping signal, every occurrence of the other state was erased
  and the survivors merged into one long run. 8640 records alternating
  Normal/Lost every minute rendered as a single 8639-minute "Normal" bar.
  Ranges are now built from every record; only transitions emit a range, so
  an entity that rarely changes stays cheap.

- Records were sorted by raw timestamp string. HA/DB history is UTC while
  get_history_with_now() appends the current state stamped in local time, so
  a string sort ordered records by their offset text and could truncate the
  timeline early. Timestamps are parsed once and sorted by instant.

- A rangeBar point's "x" is the y-axis category, and every GivEnergy Cloud
  inverter publishes a status sensor named "Status", so both inverters
  collapsed onto a single unlabelled row. Colliding names are now
  disambiguated with the entity_id.

Two consequences of the table change: a blip falling between two 5-minute
marks is no longer visible there (the chart shows every transition), and the
oldest row can read "-" where nothing had been recorded by that timestamp
instead of borrowing a reading taken later in the window.

Extends tests/test_web_history_table.py and tests/test_web_charts.py; the new
assertions were each confirmed to fail against the unfixed code.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: springfall2008

apps/predbat/tests/test_web_charts.py

@@ -8,6 +8,9 @@
 # pylint: disable=line-too-long
 # pylint: disable=attribute-defined-outside-init
 
+import re
+from datetime import datetime, timedelta, timezone
+
 from web import WebInterface
 
 
@@ -16,6 +19,83 @@ def make_web(my_predbat):
     return WebInterface(my_predbat, web_port=5053)
 
 
+def parse_timeline_ranges(html):
+    """Extract the rendered timeline ranges as a list of (category, label, start_ms, end_ms)."""
+    pattern = r"x: '([^']*)',\s*\n\s*y: \[(\d+), (\d+)\],\s*\n\s*fillColor: '[^']*',\s*\n\s*label: '([^']*)'"
+    return [(m.group(1), m.group(4), int(m.group(2)), int(m.group(3))) for m in re.finditer(pattern, html)]
+
+
+def run_web_timeline_fidelity_tests(web):
+    """A flapping state must not be erased from the timeline chart, and same-named entities must not share a row."""
+    failed = 0
+
+    # -------------------------------------------------------------------------
+    # A status sensor that alternates Normal/Lost every minute for six days. The chart used to
+    # downsample the raw samples by array index, so whenever the step landed on one phase of the
+    # flap the other state vanished entirely and the chart claimed one continuous multi-day run -
+    # contradicting the history table, which samples the same data per 5/30-minute bucket.
+    print("Test: render_timeline_chart() does not erase a state when downsampling a long flapping history")
+    now = datetime(2026, 7, 25, 14, 0, 0, tzinfo=timezone.utc)
+    samples = 8640
+    flapping = {}
+    stamp = now - timedelta(minutes=samples)
+    for index in range(samples):
+        flapping[stamp.strftime("%Y-%m-%dT%H:%M:%S%z")] = "Lost" if index % 2 else "Normal"
+        stamp += timedelta(minutes=1)
+
+    html = web.render_timeline_chart([{"name": "Status", "entity_id": "sensor.inverter_one_status", "data": flapping}], "chart_status", 7)
+    ranges = parse_timeline_ranges(html)
+    covered = {}
+    for _, label, start, end in ranges:
+        covered[label] = covered.get(label, 0) + (end - start)
+    span = sum(covered.values())
+    lost_share = covered.get("Lost", 0) / span if span else 0
+    if lost_share < 0.25:
+        print(f"  ERROR: 'Lost' holds half the history but the timeline chart gives it {lost_share:.1%} of the span - the other state was aliased over it")
+        failed += 1
+    longest = max(((end - start) / 60000 for _, label, start, end in ranges if label == "Normal"), default=0)
+    if longest > 60:
+        print(f"  ERROR: timeline chart reports a continuous {longest:.0f} minute 'Normal' run, but the state never stayed Normal for more than a minute")
+        failed += 1
+
+    # -------------------------------------------------------------------------
+    # Two inverters both publish a status sensor whose friendly name is "Status", so using the
+    # display name as the rangeBar category collapsed both onto a single y-axis row, making it
+    # impossible to tell which bar belonged to which inverter.
+    print("Test: render_timeline_chart() gives same-named entities distinct rows")
+    both = [
+        {"name": "Status", "entity_id": "sensor.inverter_one_status", "data": {"2026-07-23T10:00:00+00:00": "Normal"}},
+        {"name": "Status", "entity_id": "sensor.inverter_two_status", "data": {"2026-07-23T10:00:00+00:00": "Lost"}},
+    ]
+    html = web.render_timeline_chart(both, "chart_status", 7)
+    categories = {category for category, _, _, _ in parse_timeline_ranges(html)}
+    if len(categories) < 2:
+        print(f"  ERROR: two entities sharing the friendly name 'Status' collapsed onto one timeline row: {sorted(categories)}")
+        failed += 1
+
+    # -------------------------------------------------------------------------
+    # get_history_with_now() appends the current state stamped in local time while HA/DB history
+    # is UTC, so sorting the raw timestamp strings orders records by their text, not their instant.
+    print("Test: render_timeline_chart() orders records by instant, not by raw timestamp string")
+    mixed = {
+        "2026-07-23T09:00:00+0000": "Normal",
+        "2026-07-23T11:30:00+0200": "Lost",  # 09:30 UTC - sorts after "11:00" as text
+        "2026-07-23T10:00:00+0000": "Normal",
+    }
+    html = web.render_timeline_chart([{"name": "Status", "entity_id": "sensor.inverter_one_status", "data": mixed}], "chart_status", 7)
+    mixed_ranges = parse_timeline_ranges(html)
+    latest_ms = int(datetime(2026, 7, 23, 10, 0, 0, tzinfo=timezone.utc).timestamp() * 1000)
+    covered_to = max((end for _, _, _, end in mixed_ranges), default=0)
+    if covered_to != latest_ms:
+        print(f"  ERROR: timeline stops at {datetime.fromtimestamp(covered_to / 1000, timezone.utc)} instead of the newest record at 10:00 UTC - the 11:30+0200 record sorted last as text")
+        failed += 1
+    if [label for _, label, _, _ in mixed_ranges][:2] != ["Normal", "Lost"]:
+        print(f"  ERROR: expected the 09:30 UTC 'Lost' record to sort between the 09:00 and 10:00 UTC records, got range labels {[label for _, label, _, _ in mixed_ranges]}")
+        failed += 1
+
+    return failed
+
+
 def run_web_charts_tests(my_predbat):
     """Unit tests for chart rendering - entities with a '%' unit must still be able to chart."""
     failed = 0
@@ -69,4 +149,6 @@ def run_web_charts_tests(my_predbat):
         print(f"  ERROR: expected render_heatmap_chart() to render via a sanitised 'chart_chart__' variable, got: {html}")
         failed += 1
 
+    failed += run_web_timeline_fidelity_tests(web)
+
     return failed