Add refresh_interval: auto (#114)

* WIP Add refresh_interval: auto

* Add attribute support to automatic refresh

* Disable extending datapoints to Date.now()

* Re-add extending datapoints up to present, but now only during plotting

* Extend last datapoint into the present while plotting (not inside the cache)

* Impl. `refresh_interval: auto` for statistics

* Tweak ranges so no APIs are touched when refreshing if the visible range is already cached

Author: dbuezas

readme.md

@@ -426,16 +426,22 @@ Caveats:
 minimal_response: false # defaults to true
 ```
 
-Update data every `refresh_interval` seconds. Use `0` or delete the line to disable updates
-
 ## hours_to_show:
 
 How many hours are shown.
 Exactly the same as the history card, except decimal values (e.g `0.1`) do actually work
 
 ## refresh_interval:
 
-Update data every `refresh_interval` seconds. Use `0` or delete the line to disable updates
+Update data every `refresh_interval` seconds.
+
+Examples:
+
+```yaml
+refresh_interval: auto # (default) update automatically when an entity changes its state.
+refresh_interval: 0 # never update.
+refresh_interval: 5 # update every 5 seconds
+```
 
 # Development
 

src/cache/Cache.ts

@@ -4,12 +4,12 @@ import fetchStatistics from "./fetch-statistics";
 import fetchStates from "./fetch-states";
 import {
   TimestampRange,
-  History,
   isEntityIdAttrConfig,
   EntityConfig,
   isEntityIdStateConfig,
   isEntityIdStatisticsConfig,
   HistoryInRange,
+  EntityState,
 } from "../types";
 
 export function mapValues<T, S>(
@@ -25,13 +25,14 @@ async function fetchSingleRange(
   significant_changes_only: boolean,
   minimal_response: boolean
 ): Promise<HistoryInRange> {
-  const start = new Date(startT);
+  const start = new Date(startT - 1);
+  endT = Math.min(endT, Date.now());
   const end = new Date(endT);
-  let historyInRange: HistoryInRange;
+  let history: EntityState[];
   if (isEntityIdStatisticsConfig(entity)) {
-    historyInRange = await fetchStatistics(hass, entity, [start, end]);
+    history = await fetchStatistics(hass, entity, [start, end]);
   } else {
-    historyInRange = await fetchStates(
+    history = await fetchStates(
       hass,
       entity,
       [start, end],
@@ -40,25 +41,19 @@ async function fetchSingleRange(
     );
   }
 
-  const { history, range } = historyInRange;
   /*
-  home assistant will "invent" a datapoiont at startT with the previous known value, except if there is actually one at startT.
-  To avoid these duplicates, the "fetched range" is capped to end at the last known point instead of endT.
-  This ensures that the next fetch will start with a duplicate of the last known datapoint, which can then be removed.
-  On top of that, in order to ensure that the last known point is extended to endT, I duplicate the last datapoint
-  and set its date to endT.
+    home assistant will "invent" a datapoiont at startT with the previous
+    known value, except if there is actually one at startT.
+    To avoid these duplicates, the "fetched range" starts at startT-1,
+    but the first point is marked to be deleted (fake_boundary_datapoint).
+    Delettion occurs when merging the fetched range inside the cached history.
   */
+  let range: [number, number] = [startT, endT];
   if (history.length) {
-    const last = history[history.length - 1];
-    const dup = JSON.parse(JSON.stringify(last));
-    history[0].duplicate_datapoint = true;
-    dup.duplicate_datapoint = true;
-    dup.last_updated = Math.min(+end, Date.now());
-    history.push(dup);
+    history[0].fake_boundary_datapoint = true;
   }
-  Math.min(+end, Date.now());
   return {
-    range: [range[0], Math.min(range[1], Date.now())],
+    range,
     history,
   };
 }
@@ -75,8 +70,22 @@ export function getEntityKey(entity: EntityConfig) {
 }
 export default class Cache {
   ranges: Record<string, TimestampRange[]> = {};
-  histories: Record<string, History> = {};
+  histories: Record<string, EntityState[]> = {};
   busy = Promise.resolve(); // mutex
+
+  add(entity: EntityConfig, states: EntityState[], range: [number, number]) {
+    const entityKey = getEntityKey(entity);
+    let h = (this.histories[entityKey] ??= []);
+    h.push(...states);
+    h.sort((a, b) => a.timestamp - b.timestamp);
+    h = h.filter((x, i) => i == 0 || !x.fake_boundary_datapoint);
+    h = h.filter((_, i) => h[i - 1]?.timestamp !== h[i].timestamp);
+    this.histories[entityKey] = h;
+    this.ranges[entityKey] ??= [];
+    this.ranges[entityKey].push(range);
+    this.ranges[entityKey] = compactRanges(this.ranges[entityKey]);
+  }
+
   clearCache() {
     this.ranges = {};
     this.histories = {};
@@ -112,47 +121,34 @@ export default class Cache {
               minimal_response
             );
             if (fetchedHistory === null) continue;
-            let h = (this.histories[entityKey] ??= []);
-            h.push(...fetchedHistory.history);
-            h.sort((a, b) => a.last_updated - b.last_updated);
-            h = h.filter(
-              (x, i) => i == 0 || i == h.length - 1 || !x.duplicate_datapoint
-            );
-            h = h.filter(
-              (_, i) => h[i].last_updated !== h[i + 1]?.last_updated
-            );
-            this.histories[entityKey] = h;
-            this.ranges[entityKey].push(fetchedHistory.range);
-            this.ranges[entityKey] = compactRanges(this.ranges[entityKey]);
+            this.add(entity, fetchedHistory.history, fetchedHistory.range);
           }
         });
 
         await Promise.all(promises);
       }));
   }
 
-  private removeOutsideRange(range: TimestampRange) {
+  removeOutsideRange(range: TimestampRange) {
     this.ranges = mapValues(this.ranges, (ranges) =>
       subtractRanges(ranges, [
         [Number.NEGATIVE_INFINITY, range[0] - 1],
         [range[1] + 1, Number.POSITIVE_INFINITY],
       ])
     );
     this.histories = mapValues(this.histories, (history) => {
-      let first: History[0] | undefined;
-      let last: History[0] | undefined;
+      let first: EntityState | undefined;
+      let last: EntityState | undefined;
       const newHistory = history.filter((datum) => {
-        if (datum.last_updated <= range[0]) first = datum;
-        else if (!last && datum.last_updated >= range[1]) last = datum;
+        if (datum.timestamp <= range[0]) first = datum;
+        else if (!last && datum.timestamp >= range[1]) last = datum;
         else return true;
         return false;
       });
       if (first) {
-        first.last_updated = range[0];
         newHistory.unshift(first);
       }
       if (last) {
-        last.last_updated = range[1];
         newHistory.push(last);
       }
       return newHistory;

src/cache/fetch-states.ts

@@ -2,20 +2,22 @@ import { HomeAssistant } from "custom-card-helpers";
 import {
   EntityIdAttrConfig,
   EntityIdStateConfig,
-  History,
-  HistoryInRange,
+  EntityState,
+  HassEntity,
   isEntityIdAttrConfig,
   isEntityIdStateConfig,
 } from "../types";
-import { sleep } from "../utils";
 
 async function fetchStates(
   hass: HomeAssistant,
   entity: EntityIdStateConfig | EntityIdAttrConfig,
   [start, end]: [Date, Date],
   significant_changes_only?: boolean,
   minimal_response?: boolean
-): Promise<HistoryInRange> {
+): Promise<EntityState[]> {
+  const no_attributes_query = isEntityIdStateConfig(entity)
+    ? "no_attributes&"
+    : "";
   const minimal_response_query =
     minimal_response && isEntityIdStateConfig(entity)
       ? "minimal_response&"
@@ -26,11 +28,12 @@ async function fetchStates(
     `history/period/${start.toISOString()}?` +
     `filter_entity_id=${entity.entity}&` +
     `significant_changes_only=${significant_changes_only_query}&` +
+    `${no_attributes_query}&` +
     minimal_response_query +
     `end_time=${end.toISOString()}`;
-  let list: History | undefined;
+  let list: HassEntity[] | undefined;
   try {
-    const lists: History[] = (await hass.callApi("GET", uri)) || [];
+    const lists: HassEntity[][] = (await hass.callApi("GET", uri)) || [];
     list = lists[0];
   } catch (e: any) {
     console.error(e);
@@ -41,17 +44,14 @@ async function fetchStates(
     );
   }
   if (!list) list = [];
-  return {
-    range: [+start, +end],
-    history: list
-      .map((entry) => ({
-        ...entry,
-        state: isEntityIdAttrConfig(entity)
-          ? entry.attributes[entity.attribute] || null
-          : entry.state,
-        last_updated: +new Date(entry.last_updated || entry.last_changed),
-      }))
-      .filter(({ last_updated }) => last_updated),
-  };
+  return list
+    .map((entry) => ({
+      ...entry,
+      value: isEntityIdAttrConfig(entity)
+        ? entry.attributes[entity.attribute] || null
+        : entry.state,
+      timestamp: +new Date(entry.last_updated || entry.last_changed),
+    }))
+    .filter(({ timestamp }) => timestamp);
 }
 export default fetchStates;

src/cache/fetch-statistics.ts

@@ -1,13 +1,12 @@
 import { HomeAssistant } from "custom-card-helpers";
 import { Statistics, StatisticValue } from "../recorder-types";
-import { EntityIdStatisticsConfig, HistoryInRange } from "../types";
-import { sleep } from "../utils";
+import { EntityIdStatisticsConfig, EntityState } from "../types";
 
 async function fetchStatistics(
   hass: HomeAssistant,
   entity: EntityIdStatisticsConfig,
   [start, end]: [Date, Date]
-): Promise<HistoryInRange> {
+): Promise<EntityState[]> {
   let statistics: StatisticValue[] | null = null;
   try {
     const statsP = hass.callWS<Statistics>({
@@ -27,18 +26,10 @@ async function fetchStatistics(
     );
   }
   if (!statistics) statistics = []; //throw new Error(`Error fetching ${entity.entity}`);
-  return {
-    range: [+start, +end],
-    history: statistics.map((entry) => {
-      return {
-        entity_id: entry.statistic_id,
-        last_updated: +new Date(entry.start),
-        last_changed: +new Date(entry.start),
-        state: entry[entity.statistic] ?? "",
-        statistics: entry,
-        attributes: {},
-      };
-    }),
-  };
+  return statistics.map((entry) => ({
+    ...entry,
+    timestamp: +new Date(entry.start),
+    value: entry[entity.statistic] ?? "",
+  }));
 }
 export default fetchStatistics;