def test_get_significant_states_are_ordered(opp_recorder):
"""Test order of results from get_significant_states.
When entity ids are given, the results should be returned with the data
in the same order.
"""
opp = opp_recorder()
zero, four, _states = record_states(opp)
entity_ids = ["media_player.test", "media_player.test2"]
hist = history.get_significant_states(opp, zero, four, entity_ids)
assert list(hist.keys()) == entity_ids
entity_ids = ["media_player.test2", "media_player.test"]
hist = history.get_significant_states(opp, zero, four, entity_ids)
assert list(hist.keys()) == entity_ids
def test_get_significant_states_only(opp_recorder):
"""Test significant states when significant_states_only is set."""
opp = opp_recorder()
entity_id = "sensor.test"
def set_state(state, **kwargs):
"""Set the state."""
opp.states.set(entity_id, state, **kwargs)
wait_recording_done(opp)
return opp.states.get(entity_id)
start = dt_util.utcnow() - timedelta(minutes=4)
points = []
for i in range(1, 4):
points.append(start + timedelta(minutes=i))
states = []
with patch("openpeerpower.components.recorder.dt_util.utcnow", return_value=start):
set_state("123", attributes={"attribute": 10.64})
with patch(
"openpeerpower.components.recorder.dt_util.utcnow", return_value=points[0]
):
# Attributes are different, state not
states.append(set_state("123", attributes={"attribute": 21.42}))
with patch(
"openpeerpower.components.recorder.dt_util.utcnow", return_value=points[1]
):
# state is different, attributes not
states.append(set_state("32", attributes={"attribute": 21.42}))
with patch(
"openpeerpower.components.recorder.dt_util.utcnow", return_value=points[2]
):
# everything is different
states.append(set_state("412", attributes={"attribute": 54.23}))
hist = history.get_significant_states(opp, start, significant_changes_only=True)
assert len(hist[entity_id]) == 2
assert states[0] not in hist[entity_id]
assert states[1] in hist[entity_id]
assert states[2] in hist[entity_id]
hist = history.get_significant_states(opp, start, significant_changes_only=False)
assert len(hist[entity_id]) == 3
assert states == hist[entity_id]
def test_get_significant_states_with_initial(opp_history):
"""Test that only significant states are returned.
We should get back every thermostat change that
includes an attribute change, but only the state updates for
media player (attribute changes are not significant and not returned).
"""
opp = opp_history
zero, four, states = record_states(opp)
one = zero + timedelta(seconds=1)
one_and_half = zero + timedelta(seconds=1.5)
for entity_id in states:
if entity_id == "media_player.test":
states[entity_id] = states[entity_id][1:]
for state in states[entity_id]:
if state.last_changed == one:
state.last_changed = one_and_half
hist = get_significant_states(
opp,
one_and_half,
four,
filters=history.Filters(),
include_start_time_state=True,
)
assert states == hist
def test_get_significant_states_minimal_response(opp_history):
"""Test that only significant states are returned.
When minimal responses is set only the first and
last states return a complete state.
We should get back every thermostat change that
includes an attribute change, but only the state updates for
media player (attribute changes are not significant and not returned).
"""
opp = opp_history
zero, four, states = record_states(opp)
hist = get_significant_states(opp,
zero,
four,
filters=history.Filters(),
minimal_response=True)
# The second media_player.test state is reduced
# down to last_changed and state when minimal_response
# is set. We use JSONEncoder to make sure that are
# pre-encoded last_changed is always the same as what
# will happen with encoding a native state
input_state = states["media_player.test"][1]
orig_last_changed = json.dumps(
process_timestamp(input_state.last_changed),
cls=JSONEncoder,
).replace('"', "")
orig_state = input_state.state
states["media_player.test"][1] = {
"last_changed": orig_last_changed,
"state": orig_state,
}
assert states == hist
def test_get_significant_states(opp_history):
"""Test that only significant states are returned.
We should get back every thermostat change that
includes an attribute change, but only the state updates for
media player (attribute changes are not significant and not returned).
"""
opp = opp_history
zero, four, states = record_states(opp)
hist = get_significant_states(opp, zero, four, filters=history.Filters())
assert states == hist
def test_get_significant_states_entity_id(opp_recorder):
"""Test that only significant states are returned for one entity."""
opp = opp_recorder()
zero, four, states = record_states(opp)
del states["media_player.test2"]
del states["media_player.test3"]
del states["thermostat.test"]
del states["thermostat.test2"]
del states["script.can_cancel_this_one"]
hist = history.get_significant_states(opp, zero, four, ["media_player.test"])
assert states == hist
def test_compile_hourly_statistics_unavailable(opp_recorder):
"""Test compiling hourly statistics, with the sensor being unavailable."""
opp = opp_recorder()
recorder = opp.data[DATA_INSTANCE]
setup_component(opp, "sensor", {})
zero, four, states = record_states_partially_unavailable(opp)
hist = history.get_significant_states(opp, zero, four)
assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(period="hourly", start=four)
wait_recording_done(opp)
stats = statistics_during_period(opp, four)
assert stats == {}
def check_significant_states(opp, zero, four, states, config):
"""Check if significant states are retrieved."""
filters = history.Filters()
exclude = config[history.DOMAIN].get(history.CONF_EXCLUDE)
if exclude:
filters.excluded_entities = exclude.get(history.CONF_ENTITIES, [])
filters.excluded_domains = exclude.get(history.CONF_DOMAINS, [])
include = config[history.DOMAIN].get(history.CONF_INCLUDE)
if include:
filters.included_entities = include.get(history.CONF_ENTITIES, [])
filters.included_domains = include.get(history.CONF_DOMAINS, [])
hist = get_significant_states(opp, zero, four, filters=filters)
assert states == hist
def test_get_significant_states_multiple_entity_ids(opp_history):
"""Test that only significant states are returned for one entity."""
opp = opp_history
zero, four, states = record_states(opp)
del states["media_player.test2"]
del states["media_player.test3"]
del states["thermostat.test2"]
del states["script.can_cancel_this_one"]
hist = get_significant_states(
opp,
zero,
four,
["media_player.test", "thermostat.test"],
filters=history.Filters(),
)
assert states == hist
def test_get_significant_states_without_initial(opp_history):
"""Test that only significant states are returned.
We should get back every thermostat change that
includes an attribute change, but only the state updates for
media player (attribute changes are not significant and not returned).
"""
opp = opp_history
zero, four, states = record_states(opp)
one = zero + timedelta(seconds=1)
one_and_half = zero + timedelta(seconds=1.5)
for entity_id in states:
states[entity_id] = list(
filter(lambda s: s.last_changed != one, states[entity_id]))
del states["media_player.test2"]
hist = get_significant_states(
opp,
one_and_half,
four,
filters=history.Filters(),
include_start_time_state=False,
)
assert states == hist
def test_compile_hourly_statistics(opp_recorder):
"""Test compiling hourly statistics."""
opp = opp_recorder()
recorder = opp.data[DATA_INSTANCE]
setup_component(opp, "sensor", {})
zero, four, states = record_states(opp)
hist = history.get_significant_states(opp, zero, four)
assert dict(states) == dict(hist)
recorder.do_adhoc_statistics(period="hourly", start=zero)
wait_recording_done(opp)
stats = statistics_during_period(opp, zero)
assert stats == {
"sensor.test1": [{
"statistic_id": "sensor.test1",
"start": process_timestamp_to_utc_isoformat(zero),
"mean": approx(14.915254237288135),
"min": approx(10.0),
"max": approx(20.0),
"last_reset": None,
"state": None,
"sum": None,
}]
}
def get_significant_states(opp, *args, **kwargs):
"""Wrap _get_significant_states with an sql session."""
return history.get_significant_states(opp, *args, **kwargs)
def compile_statistics(opp: OpenPeerPower, start: datetime.datetime,
end: datetime.datetime) -> dict:
"""Compile statistics for all entities during start-end.
Note: This will query the database and must not be run in the event loop
"""
result: dict = {}
entities = _get_entities(opp)
# Get history between start and end
history_list = history.get_significant_states( # type: ignore
opp, start - datetime.timedelta.resolution, end,
[i[0] for i in entities])
for entity_id, device_class in entities:
wanted_statistics = DEVICE_CLASS_STATISTICS[device_class]
if entity_id not in history_list:
continue
entity_history = history_list[entity_id]
fstates = [(float(el.state), el) for el in entity_history
if _is_number(el.state)]
if not fstates:
continue
result[entity_id] = {}
# Make calculations
if "max" in wanted_statistics:
result[entity_id]["max"] = max(*itertools.islice(zip(*fstates), 1))
if "min" in wanted_statistics:
result[entity_id]["min"] = min(*itertools.islice(zip(*fstates), 1))
if "mean" in wanted_statistics:
result[entity_id]["mean"] = _time_weighted_average(
fstates, start, end)
if "sum" in wanted_statistics:
last_reset = old_last_reset = None
new_state = old_state = None
_sum = 0
last_stats = statistics.get_last_statistics(
opp, 1, entity_id) # type: ignore
if entity_id in last_stats:
# We have compiled history for this sensor before, use that as a starting point
last_reset = old_last_reset = last_stats[entity_id][0][
"last_reset"]
new_state = old_state = last_stats[entity_id][0]["state"]
_sum = last_stats[entity_id][0]["sum"]
for fstate, state in fstates:
if "last_reset" not in state.attributes:
continue
if (last_reset :=
state.attributes["last_reset"]) != old_last_reset:
# The sensor has been reset, update the sum
if old_state is not None:
_sum += new_state - old_state
# ..and update the starting point
new_state = fstate
old_last_reset = last_reset
old_state = new_state
else:
new_state = fstate
if last_reset is None or new_state is None or old_state is None:
# No valid updates
result.pop(entity_id)
continue
# Update the sum with the last state
_sum += new_state - old_state
result[entity_id]["last_reset"] = dt_util.parse_datetime(
last_reset)
result[entity_id]["sum"] = _sum
result[entity_id]["state"] = new_state
def test_compile_hourly_energy_statistics(opp_recorder):
"""Test compiling hourly statistics."""
opp = opp_recorder()
recorder = opp.data[DATA_INSTANCE]
setup_component(opp, "sensor", {})
sns1_attr = {"device_class": "energy", "state_class": "measurement"}
sns2_attr = {"device_class": "energy"}
sns3_attr = {}
zero, four, eight, states = record_energy_states(opp, sns1_attr, sns2_attr,
sns3_attr)
hist = history.get_significant_states(opp, zero - timedelta.resolution,
eight + timedelta.resolution)
assert dict(states)["sensor.test1"] == dict(hist)["sensor.test1"]
recorder.do_adhoc_statistics(period="hourly", start=zero)
wait_recording_done(opp)
recorder.do_adhoc_statistics(period="hourly",
start=zero + timedelta(hours=1))
wait_recording_done(opp)
recorder.do_adhoc_statistics(period="hourly",
start=zero + timedelta(hours=2))
wait_recording_done(opp)
stats = statistics_during_period(opp, zero)
assert stats == {
"sensor.test1": [
{
"statistic_id": "sensor.test1",
"start": process_timestamp_to_utc_isoformat(zero),
"max": None,
"mean": None,
"min": None,
"last_reset": process_timestamp_to_utc_isoformat(zero),
"state": approx(20.0),
"sum": approx(10.0),
},
{
"statistic_id":
"sensor.test1",
"start":
process_timestamp_to_utc_isoformat(zero + timedelta(hours=1)),
"max":
None,
"mean":
None,
"min":
None,
"last_reset":
process_timestamp_to_utc_isoformat(four),
"state":
approx(40.0),
"sum":
approx(10.0),
},
{
"statistic_id":
"sensor.test1",
"start":
process_timestamp_to_utc_isoformat(zero + timedelta(hours=2)),
"max":
None,
"mean":
None,
"min":
None,
"last_reset":
process_timestamp_to_utc_isoformat(four),
"state":
approx(70.0),
"sum":
approx(40.0),
},
]
}
