a2e45b8fdd
* Switch to SQLAlchemy for the Recorder component. Gives the ability to use MySQL or other. * fixes for failed lint * add conversion script * code review fixes and refactor to use to_native() model methods and execute() helper * move script to homeassistant.scripts module * style fixes my tox lint/flake8 missed * move exclusion up
151 lines
5 KiB
Python
151 lines
5 KiB
Python
"""Models for SQLAlchemy."""
|
|
|
|
import json
|
|
from datetime import datetime
|
|
import logging
|
|
|
|
from sqlalchemy import (Boolean, Column, DateTime, ForeignKey, Index, Integer,
|
|
String, Text, distinct)
|
|
from sqlalchemy.ext.declarative import declarative_base
|
|
import homeassistant.util.dt as dt_util
|
|
from homeassistant.core import Event, EventOrigin, State
|
|
from homeassistant.remote import JSONEncoder
|
|
|
|
# SQLAlchemy Schema
|
|
# pylint: disable=invalid-name
|
|
Base = declarative_base()
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
class Events(Base):
|
|
# pylint: disable=too-few-public-methods
|
|
"""Event history data."""
|
|
|
|
__tablename__ = 'events'
|
|
event_id = Column(Integer, primary_key=True)
|
|
event_type = Column(String(32), index=True)
|
|
event_data = Column(Text)
|
|
origin = Column(String(32))
|
|
time_fired = Column(DateTime(timezone=True))
|
|
created = Column(DateTime(timezone=True), default=datetime.utcnow)
|
|
|
|
@staticmethod
|
|
def record_event(session, event):
|
|
"""Save an event to the database."""
|
|
dbevent = Events(event_type=event.event_type,
|
|
event_data=json.dumps(event.data, cls=JSONEncoder),
|
|
origin=str(event.origin),
|
|
time_fired=event.time_fired)
|
|
|
|
session.add(dbevent)
|
|
session.commit()
|
|
|
|
return dbevent.event_id
|
|
|
|
def to_native(self):
|
|
"""Convert to a natve HA Event."""
|
|
try:
|
|
return Event(
|
|
self.event_type,
|
|
json.loads(self.event_data),
|
|
EventOrigin(self.origin),
|
|
dt_util.UTC.localize(self.time_fired)
|
|
)
|
|
except ValueError:
|
|
# When json.loads fails
|
|
_LOGGER.exception("Error converting to event: %s", self)
|
|
return None
|
|
|
|
|
|
class States(Base):
|
|
# pylint: disable=too-few-public-methods
|
|
"""State change history."""
|
|
|
|
__tablename__ = 'states'
|
|
state_id = Column(Integer, primary_key=True)
|
|
domain = Column(String(64))
|
|
entity_id = Column(String(64))
|
|
state = Column(String(255))
|
|
attributes = Column(Text)
|
|
origin = Column(String(32))
|
|
event_id = Column(Integer, ForeignKey('events.event_id'))
|
|
last_changed = Column(DateTime(timezone=True), default=datetime.utcnow)
|
|
last_updated = Column(DateTime(timezone=True), default=datetime.utcnow)
|
|
created = Column(DateTime(timezone=True), default=datetime.utcnow)
|
|
|
|
__table_args__ = (Index('states__state_changes',
|
|
'last_changed', 'last_updated', 'entity_id'),
|
|
Index('states__significant_changes',
|
|
'domain', 'last_updated', 'entity_id'), )
|
|
|
|
@staticmethod
|
|
def record_state(session, entity_id, state, event_id):
|
|
"""Save a state to the database."""
|
|
now = dt_util.utcnow()
|
|
|
|
dbstate = States(event_id=event_id, entity_id=entity_id)
|
|
|
|
# State got deleted
|
|
if state is None:
|
|
dbstate.state = ''
|
|
dbstate.domain = ''
|
|
dbstate.attributes = '{}'
|
|
dbstate.last_changed = now
|
|
dbstate.last_updated = now
|
|
else:
|
|
dbstate.domain = state.domain
|
|
dbstate.state = state.state
|
|
dbstate.attributes = json.dumps(dict(state.attributes))
|
|
dbstate.last_changed = state.last_changed
|
|
dbstate.last_updated = state.last_updated
|
|
|
|
session().add(dbstate)
|
|
session().commit()
|
|
|
|
def to_native(self):
|
|
"""Convert to an HA state object."""
|
|
try:
|
|
return State(
|
|
self.entity_id, self.state,
|
|
json.loads(self.attributes),
|
|
dt_util.UTC.localize(self.last_changed),
|
|
dt_util.UTC.localize(self.last_updated)
|
|
)
|
|
except ValueError:
|
|
# When json.loads fails
|
|
_LOGGER.exception("Error converting row to state: %s", self)
|
|
return None
|
|
|
|
|
|
class RecorderRuns(Base):
|
|
# pylint: disable=too-few-public-methods
|
|
"""Representation of recorder run."""
|
|
|
|
__tablename__ = 'recorder_runs'
|
|
run_id = Column(Integer, primary_key=True)
|
|
start = Column(DateTime(timezone=True), default=datetime.utcnow)
|
|
end = Column(DateTime(timezone=True))
|
|
closed_incorrect = Column(Boolean, default=False)
|
|
created = Column(DateTime(timezone=True), default=datetime.utcnow)
|
|
|
|
def entity_ids(self, point_in_time=None):
|
|
"""Return the entity ids that existed in this run.
|
|
|
|
Specify point_in_time if you want to know which existed at that point
|
|
in time inside the run.
|
|
"""
|
|
from homeassistant.components.recorder import Session, _verify_instance
|
|
_verify_instance()
|
|
|
|
query = Session().query(distinct(States.entity_id)).filter(
|
|
States.created >= self.start)
|
|
|
|
if point_in_time is not None or self.end is not None:
|
|
query = query.filter(States.created < point_in_time)
|
|
|
|
return [row.entity_id for row in query]
|
|
|
|
def to_native(self):
|
|
"""Return self, native format is this model."""
|
|
return self
|