def test_from_event(self):
"""Test converting event to db state."""
state = ha.State('sensor.temperature', '18')
event = ha.Event(EVENT_STATE_CHANGED, {
'entity_id': 'sensor.temperature',
'old_state': None,
'new_state': state,
}, context=state.context)
assert state == States.from_event(event).to_native()
def test_from_event(self):
"""Test converting event to db state."""
state = ha.State('sensor.temperature', '18')
event = ha.Event(EVENT_STATE_CHANGED, {
'entity_id': 'sensor.temperature',
'old_state': None,
'new_state': state,
})
assert state == States.from_event(event).to_native()
def run(self):
"""Start processing events to save."""
from homeassistant.components.recorder.models import Events, States
import sqlalchemy.exc
while True:
try:
self._setup_connection()
self._setup_run()
break
except sqlalchemy.exc.SQLAlchemyError as e:
log_error(e,
retry_wait=CONNECT_RETRY_WAIT,
rollback=False,
message="Error during connection setup: %s")
if self.purge_days is not None:
def purge_ticker(event):
"""Rerun purge every second day."""
self._purge_old_data()
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(days=2))
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(minutes=5))
while True:
event = self.queue.get()
if event == self.quit_object:
self._close_run()
self._close_connection()
# pylint: disable=global-statement
global _INSTANCE
_INSTANCE = None
self.queue.task_done()
return
if event.event_type == EVENT_TIME_CHANGED:
self.queue.task_done()
continue
dbevent = Events.from_event(event)
self._commit(dbevent)
if event.event_type != EVENT_STATE_CHANGED:
self.queue.task_done()
continue
dbstate = States.from_event(event)
dbstate.event_id = dbevent.event_id
self._commit(dbstate)
self.queue.task_done()
def test_from_event_to_db_state():
"""Test converting event to db state."""
state = ha.State("sensor.temperature", "18")
event = ha.Event(
EVENT_STATE_CHANGED,
{
"entity_id": "sensor.temperature",
"old_state": None,
"new_state": state
},
context=state.context,
)
assert state == States.from_event(event).to_native()
def run(self):
"""Start processing events to save."""
from homeassistant.components.recorder.models import Events, States
import sqlalchemy.exc
while True:
try:
self._setup_connection()
self._setup_run()
break
except sqlalchemy.exc.SQLAlchemyError as e:
log_error(e, retry_wait=CONNECT_RETRY_WAIT, rollback=False,
message="Error during connection setup: %s")
if self.purge_days is not None:
def purge_ticker(event):
"""Rerun purge every second day."""
self._purge_old_data()
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(days=2))
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(minutes=5))
while True:
event = self.queue.get()
if event == self.quit_object:
self._close_run()
self._close_connection()
# pylint: disable=global-statement
global _INSTANCE
_INSTANCE = None
self.queue.task_done()
return
if event.event_type == EVENT_TIME_CHANGED:
self.queue.task_done()
continue
dbevent = Events.from_event(event)
self._commit(dbevent)
if event.event_type != EVENT_STATE_CHANGED:
self.queue.task_done()
continue
dbstate = States.from_event(event)
dbstate.event_id = dbevent.event_id
self._commit(dbstate)
self.queue.task_done()
def test_from_event_to_delete_state(self):
"""Test converting deleting state event to db state."""
event = ha.Event(EVENT_STATE_CHANGED, {
'entity_id': 'sensor.temperature',
'old_state': ha.State('sensor.temperature', '18'),
'new_state': None,
})
db_state = States.from_event(event)
assert db_state.entity_id == 'sensor.temperature'
assert db_state.domain == 'sensor'
assert db_state.state == ''
assert db_state.last_changed == event.time_fired
assert db_state.last_updated == event.time_fired
def test_from_event_to_delete_state(self):
"""Test converting deleting state event to db state."""
event = ha.Event(EVENT_STATE_CHANGED, {
'entity_id': 'sensor.temperature',
'old_state': ha.State('sensor.temperature', '18'),
'new_state': None,
})
db_state = States.from_event(event)
assert db_state.entity_id == 'sensor.temperature'
assert db_state.domain == 'sensor'
assert db_state.state == ''
assert db_state.last_changed == event.time_fired
assert db_state.last_updated == event.time_fired
def test_from_event_to_delete_state():
"""Test converting deleting state event to db state."""
event = ha.Event(
EVENT_STATE_CHANGED,
{
"entity_id": "sensor.temperature",
"old_state": ha.State("sensor.temperature", "18"),
"new_state": None,
},
)
db_state = States.from_event(event)
assert db_state.entity_id == "sensor.temperature"
assert db_state.state == ""
assert db_state.last_changed == event.time_fired
assert db_state.last_updated == event.time_fired
def test_from_event_to_db_state():
"""Test converting event to db state."""
state = ha.State("sensor.temperature", "18")
event = ha.Event(
EVENT_STATE_CHANGED,
{
"entity_id": "sensor.temperature",
"old_state": None,
"new_state": state
},
context=state.context,
)
# We don't restore context unless we need it by joining the
# events table on the event_id for state_changed events
state.context = ha.Context(id=None)
assert state == States.from_event(event).to_native()
def run(self):
"""Start processing events to save."""
from homeassistant.components.recorder.models import Events, States
import sqlalchemy.exc
while True:
try:
self._setup_connection()
self._setup_run()
break
except sqlalchemy.exc.SQLAlchemyError as e:
log_error(e, retry_wait=CONNECT_RETRY_WAIT, rollback=False,
message="Error during connection setup: %s")
if self.purge_days is not None:
def purge_ticker(event):
"""Rerun purge every second day."""
self._purge_old_data()
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(days=2))
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(minutes=5))
while True:
event = self.queue.get()
if event is None:
self._close_run()
self._close_connection()
self.queue.task_done()
return
if event.event_type == EVENT_TIME_CHANGED:
self.queue.task_done()
continue
if ATTR_ENTITY_ID in event.data:
entity_id = event.data[ATTR_ENTITY_ID]
domain = split_entity_id(entity_id)[0]
# Exclude entities OR
# Exclude domains, but include specific entities
if (entity_id in self.exclude) or \
(domain in self.exclude and
entity_id not in self.include_e):
self.queue.task_done()
continue
# Included domains only (excluded entities above) OR
# Include entities only, but only if no excludes
if (self.include_d and domain not in self.include_d) or \
(self.include_e and entity_id not in self.include_e
and not self.exclude):
self.queue.task_done()
continue
dbevent = Events.from_event(event)
self._commit(dbevent)
if event.event_type != EVENT_STATE_CHANGED:
self.queue.task_done()
continue
dbstate = States.from_event(event)
dbstate.event_id = dbevent.event_id
self._commit(dbstate)
self.queue.task_done()
def run(self):
"""Start processing events to save."""
from homeassistant.components.recorder.models import Events, States
from sqlalchemy.exc import SQLAlchemyError
while True:
try:
self._setup_connection()
self._setup_run()
self.db_ready.set()
self.hass.loop.call_soon_threadsafe(self.async_db_ready.set)
break
except SQLAlchemyError as err:
_LOGGER.error("Error during connection setup: %s (retrying "
"in %s seconds)", err, CONNECT_RETRY_WAIT)
time.sleep(CONNECT_RETRY_WAIT)
if self.purge_days is not None:
async_track_time_interval(
self.hass, self._purge_old_data, timedelta(days=2))
while True:
event = self.queue.get()
if event is None:
self._close_run()
self._close_connection()
self.queue.task_done()
return
if event.event_type == EVENT_TIME_CHANGED:
self.queue.task_done()
continue
if ATTR_ENTITY_ID in event.data:
entity_id = event.data[ATTR_ENTITY_ID]
domain = split_entity_id(entity_id)[0]
# Exclude entities OR
# Exclude domains, but include specific entities
if (entity_id in self.exclude) or \
(domain in self.exclude and
entity_id not in self.include_e):
self.queue.task_done()
continue
# Included domains only (excluded entities above) OR
# Include entities only, but only if no excludes
if (self.include_d and domain not in self.include_d) or \
(self.include_e and entity_id not in self.include_e
and not self.exclude):
self.queue.task_done()
continue
with session_scope() as session:
dbevent = Events.from_event(event)
self._commit(session, dbevent)
if event.event_type != EVENT_STATE_CHANGED:
self.queue.task_done()
continue
dbstate = States.from_event(event)
dbstate.event_id = dbevent.event_id
self._commit(session, dbstate)
self.queue.task_done()
def run(self):
"""Start processing events to save."""
from homeassistant.components.recorder.models import Events, States
import sqlalchemy.exc
while True:
try:
self._setup_connection()
self._setup_run()
break
except sqlalchemy.exc.SQLAlchemyError as e:
log_error(e,
retry_wait=CONNECT_RETRY_WAIT,
rollback=False,
message="Error during connection setup: %s")
if self.purge_days is not None:
def purge_ticker(event):
"""Rerun purge every second day."""
self._purge_old_data()
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(days=2))
track_point_in_utc_time(self.hass, purge_ticker,
dt_util.utcnow() + timedelta(minutes=5))
while True:
event = self.queue.get()
if event is None:
self._close_run()
self._close_connection()
self.queue.task_done()
return
if event.event_type == EVENT_TIME_CHANGED:
self.queue.task_done()
continue
if ATTR_ENTITY_ID in event.data:
entity_id = event.data[ATTR_ENTITY_ID]
domain = split_entity_id(entity_id)[0]
# Exclude entities OR
# Exclude domains, but include specific entities
if (entity_id in self.exclude) or \
(domain in self.exclude and
entity_id not in self.include_e):
self.queue.task_done()
continue
# Included domains only (excluded entities above) OR
# Include entities only, but only if no excludes
if (self.include_d and domain not in self.include_d) or \
(self.include_e and entity_id not in self.include_e
and not self.exclude):
self.queue.task_done()
continue
dbevent = Events.from_event(event)
self._commit(dbevent)
if event.event_type != EVENT_STATE_CHANGED:
self.queue.task_done()
continue
dbstate = States.from_event(event)
dbstate.event_id = dbevent.event_id
self._commit(dbstate)
self.queue.task_done()
def run(self):
"""Start processing events to save."""
from homeassistant.components.recorder.models import Events, States
import sqlalchemy.exc
while True:
try:
self._setup_connection()
self._setup_run()
break
except sqlalchemy.exc.SQLAlchemyError as err:
_LOGGER.error(
"Error during connection setup: %s (retrying "
"in %s seconds)", err, CONNECT_RETRY_WAIT)
time.sleep(CONNECT_RETRY_WAIT)
if self.purge_days is not None:
async_track_time_interval(self.hass, self._purge_old_data,
timedelta(days=2))
while True:
event = self.queue.get()
if event is None:
self._close_run()
self._close_connection()
self.queue.task_done()
return
if event.event_type == EVENT_TIME_CHANGED:
self.queue.task_done()
continue
if ATTR_ENTITY_ID in event.data:
entity_id = event.data[ATTR_ENTITY_ID]
domain = split_entity_id(entity_id)[0]
# Exclude entities OR
# Exclude domains, but include specific entities
if (entity_id in self.exclude) or \
(domain in self.exclude and
entity_id not in self.include_e):
self.queue.task_done()
continue
# Included domains only (excluded entities above) OR
# Include entities only, but only if no excludes
if (self.include_d and domain not in self.include_d) or \
(self.include_e and entity_id not in self.include_e
and not self.exclude):
self.queue.task_done()
continue
with session_scope() as session:
dbevent = Events.from_event(event)
self._commit(session, dbevent)
if event.event_type != EVENT_STATE_CHANGED:
self.queue.task_done()
continue
dbstate = States.from_event(event)
dbstate.event_id = dbevent.event_id
self._commit(session, dbstate)
self.queue.task_done()
