class TadoHelper:
def __init__(self, account, pwd):
self.my_tado = Tado(account, pwd)
def checkWindowState(self):
zones = self.my_tado.getZones()
for index, zone in enumerate(zones):
if self.windowOpen(zone['id']):
_LOG_.info('window open')
self.my_tado.setOpenWindow(zone['id'])
else:
_LOG_.debug('window closed')
def windowOpen(self, zone_id):
window_open = self.my_tado.getOpenWindowDetected(zone_id)
return window_open['openWindowDetected']
class TadoConnector:
"""An object to store the Tado data."""
def __init__(self, hass, username, password):
"""Initialize Tado Connector."""
self.hass = hass
self._username = username
self._password = password
self.tado = None
self.zones = None
self.devices = None
self.data = {
"zone": {},
"device": {},
}
def setup(self):
"""Connect to Tado and fetch the zones."""
try:
self.tado = Tado(self._username, self._password)
except (RuntimeError, urllib.error.HTTPError) as exc:
_LOGGER.error("Unable to connect: %s", exc)
return False
self.tado.setDebugging(True)
# Load zones and devices
self.zones = self.tado.getZones()
self.devices = self.tado.getMe()["homes"]
return True
@Throttle(MIN_TIME_BETWEEN_UPDATES)
def update(self):
"""Update the registered zones."""
for zone in self.zones:
self.update_sensor("zone", zone["id"])
for device in self.devices:
self.update_sensor("device", device["id"])
def update_sensor(self, sensor_type, sensor):
"""Update the internal data from Tado."""
_LOGGER.debug("Updating %s %s", sensor_type, sensor)
try:
if sensor_type == "zone":
data = self.tado.getState(sensor)
elif sensor_type == "device":
data = self.tado.getDevices()[0]
else:
_LOGGER.debug("Unknown sensor: %s", sensor_type)
return
except RuntimeError:
_LOGGER.error(
"Unable to connect to Tado while updating %s %s", sensor_type, sensor,
)
return
self.data[sensor_type][sensor] = data
_LOGGER.debug("Dispatching update to %s %s: %s", sensor_type, sensor, data)
dispatcher_send(
self.hass, SIGNAL_TADO_UPDATE_RECEIVED.format(sensor_type, sensor)
)
def get_capabilities(self, zone_id):
"""Return the capabilities of the devices."""
return self.tado.getCapabilities(zone_id)
def reset_zone_overlay(self, zone_id):
"""Reset the zone back to the default operation."""
self.tado.resetZoneOverlay(zone_id)
self.update_sensor("zone", zone_id)
def set_zone_overlay(
self,
zone_id,
overlay_mode,
temperature=None,
duration=None,
device_type="HEATING",
mode=None,
):
"""Set a zone overlay."""
_LOGGER.debug(
"Set overlay for zone %s: mode=%s, temp=%s, duration=%s, type=%s, mode=%s",
zone_id,
overlay_mode,
temperature,
duration,
device_type,
mode,
)
try:
self.tado.setZoneOverlay(
zone_id, overlay_mode, temperature, duration, device_type, "ON", mode
)
except urllib.error.HTTPError as exc:
_LOGGER.error("Could not set zone overlay: %s", exc.read())
self.update_sensor("zone", zone_id)
def set_zone_off(self, zone_id, overlay_mode, device_type="HEATING"):
"""Set a zone to off."""
try:
self.tado.setZoneOverlay(
zone_id, overlay_mode, None, None, device_type, "OFF"
)
except urllib.error.HTTPError as exc:
_LOGGER.error("Could not set zone overlay: %s", exc.read())
self.update_sensor("zone", zone_id)
class TadoConnector:
"""An object to store the Tado data."""
def __init__(self, hass, username, password, fallback):
"""Initialize Tado Connector."""
self.hass = hass
self._username = username
self._password = password
self._fallback = fallback
self.device_id = None
self.tado = None
self.zones = None
self.devices = None
self.data = {
"zone": {},
"device": {},
}
@property
def fallback(self):
"""Return fallback flag to Smart Schedule."""
return self._fallback
def setup(self):
"""Connect to Tado and fetch the zones."""
self.tado = Tado(self._username, self._password)
self.tado.setDebugging(True)
# Load zones and devices
self.zones = self.tado.getZones()
self.devices = self.tado.getMe()["homes"]
self.device_id = self.devices[0]["id"]
@Throttle(MIN_TIME_BETWEEN_UPDATES)
def update(self):
"""Update the registered zones."""
for zone in self.zones:
self.update_sensor("zone", zone["id"])
for device in self.devices:
self.update_sensor("device", device["id"])
def update_sensor(self, sensor_type, sensor):
"""Update the internal data from Tado."""
_LOGGER.debug("Updating %s %s", sensor_type, sensor)
try:
if sensor_type == "zone":
data = self.tado.getZoneState(sensor)
elif sensor_type == "device":
devices_data = self.tado.getDevices()
if not devices_data:
_LOGGER.info(
"There are no devices to setup on this tado account")
return
data = devices_data[0]
else:
_LOGGER.debug("Unknown sensor: %s", sensor_type)
return
except RuntimeError:
_LOGGER.error(
"Unable to connect to Tado while updating %s %s",
sensor_type,
sensor,
)
return
self.data[sensor_type][sensor] = data
_LOGGER.debug(
"Dispatching update to %s %s %s: %s",
self.device_id,
sensor_type,
sensor,
data,
)
dispatcher_send(
self.hass,
SIGNAL_TADO_UPDATE_RECEIVED.format(self.device_id, sensor_type,
sensor),
)
def get_capabilities(self, zone_id):
"""Return the capabilities of the devices."""
return self.tado.getCapabilities(zone_id)
def reset_zone_overlay(self, zone_id):
"""Reset the zone back to the default operation."""
self.tado.resetZoneOverlay(zone_id)
self.update_sensor("zone", zone_id)
def set_presence(
self,
presence=PRESET_HOME,
):
"""Set the presence to home or away."""
if presence == PRESET_AWAY:
self.tado.setAway()
elif presence == PRESET_HOME:
self.tado.setHome()
def set_zone_overlay(
self,
zone_id=None,
overlay_mode=None,
temperature=None,
duration=None,
device_type="HEATING",
mode=None,
fan_speed=None,
swing=None,
):
"""Set a zone overlay."""
_LOGGER.debug(
"Set overlay for zone %s: overlay_mode=%s, temp=%s, duration=%s, type=%s, mode=%s fan_speed=%s swing=%s",
zone_id,
overlay_mode,
temperature,
duration,
device_type,
mode,
fan_speed,
swing,
)
try:
self.tado.setZoneOverlay(
zone_id,
overlay_mode,
temperature,
duration,
device_type,
"ON",
mode,
fanSpeed=fan_speed,
swing=swing,
)
except RequestException as exc:
_LOGGER.error("Could not set zone overlay: %s", exc)
self.update_sensor("zone", zone_id)
def set_zone_off(self, zone_id, overlay_mode, device_type="HEATING"):
"""Set a zone to off."""
try:
self.tado.setZoneOverlay(zone_id, overlay_mode, None, None,
device_type, "OFF")
except RequestException as exc:
_LOGGER.error("Could not set zone overlay: %s", exc)
self.update_sensor("zone", zone_id)
class TadoConnector:
"""An object to store the Tado data."""
def __init__(self, opp, username, password, fallback):
"""Initialize Tado Connector."""
self.opp = opp
self._username = username
self._password = password
self._fallback = fallback
self.home_id = None
self.home_name = None
self.tado = None
self.zones = None
self.devices = None
self.data = {
"device": {},
"weather": {},
"zone": {},
}
@property
def fallback(self):
"""Return fallback flag to Smart Schedule."""
return self._fallback
def setup(self):
"""Connect to Tado and fetch the zones."""
self.tado = Tado(self._username, self._password)
self.tado.setDebugging(True)
# Load zones and devices
self.zones = self.tado.getZones()
self.devices = self.tado.getDevices()
tado_home = self.tado.getMe()["homes"][0]
self.home_id = tado_home["id"]
self.home_name = tado_home["name"]
@Throttle(MIN_TIME_BETWEEN_UPDATES)
def update(self):
"""Update the registered zones."""
for device in self.devices:
self.update_sensor("device", device["shortSerialNo"])
for zone in self.zones:
self.update_sensor("zone", zone["id"])
self.data["weather"] = self.tado.getWeather()
dispatcher_send(
self.opp,
SIGNAL_TADO_UPDATE_RECEIVED.format(self.home_id, "weather", "data"),
)
def update_sensor(self, sensor_type, sensor):
"""Update the internal data from Tado."""
_LOGGER.debug("Updating %s %s", sensor_type, sensor)
try:
if sensor_type == "device":
data = self.tado.getDeviceInfo(sensor)
if (
INSIDE_TEMPERATURE_MEASUREMENT
in data["characteristics"]["capabilities"]
):
data[TEMP_OFFSET] = self.tado.getDeviceInfo(sensor, TEMP_OFFSET)
elif sensor_type == "zone":
data = self.tado.getZoneState(sensor)
else:
_LOGGER.debug("Unknown sensor: %s", sensor_type)
return
except RuntimeError:
_LOGGER.error(
"Unable to connect to Tado while updating %s %s",
sensor_type,
sensor,
)
return
self.data[sensor_type][sensor] = data
_LOGGER.debug(
"Dispatching update to %s %s %s: %s",
self.home_id,
sensor_type,
sensor,
data,
)
dispatcher_send(
self.opp,
SIGNAL_TADO_UPDATE_RECEIVED.format(self.home_id, sensor_type, sensor),
)
def get_capabilities(self, zone_id):
"""Return the capabilities of the devices."""
return self.tado.getCapabilities(zone_id)
def reset_zone_overlay(self, zone_id):
"""Reset the zone back to the default operation."""
self.tado.resetZoneOverlay(zone_id)
self.update_sensor("zone", zone_id)
def set_presence(
self,
presence=PRESET_HOME,
):
"""Set the presence to home or away."""
if presence == PRESET_AWAY:
self.tado.setAway()
elif presence == PRESET_HOME:
self.tado.setHome()
def set_zone_overlay(
self,
zone_id=None,
overlay_mode=None,
temperature=None,
duration=None,
device_type="HEATING",
mode=None,
fan_speed=None,
swing=None,
):
"""Set a zone overlay."""
_LOGGER.debug(
"Set overlay for zone %s: overlay_mode=%s, temp=%s, duration=%s, type=%s, mode=%s fan_speed=%s swing=%s",
zone_id,
overlay_mode,
temperature,
duration,
device_type,
mode,
fan_speed,
swing,
)
try:
self.tado.setZoneOverlay(
zone_id,
overlay_mode,
temperature,
duration,
device_type,
"ON",
mode,
fanSpeed=fan_speed,
swing=swing,
)
except RequestException as exc:
_LOGGER.error("Could not set zone overlay: %s", exc)
self.update_sensor("zone", zone_id)
def set_zone_off(self, zone_id, overlay_mode, device_type="HEATING"):
"""Set a zone to off."""
try:
self.tado.setZoneOverlay(
zone_id, overlay_mode, None, None, device_type, "OFF"
)
except RequestException as exc:
_LOGGER.error("Could not set zone overlay: %s", exc)
self.update_sensor("zone", zone_id)
def set_temperature_offset(self, device_id, offset):
"""Set temperature offset of device."""
try:
self.tado.setTempOffset(device_id, offset)
except RequestException as exc:
_LOGGER.error("Could not set temperature offset: %s", exc)
sys.path.append(libdir)
from PyTado.interface import Tado
import private
mysql = pymysql.connect(host=os.getenv('MYSQL_HOST', private.mysql_host),
user=os.getenv('MYSQL_USER', private.mysql_user),
password=os.getenv('MYSQL_PASSWORD', private.mysql_password),
db=os.getenv('MYSQL_DATABASE', private.mysql_database))
api = Tado(private.username, private.password)
weather = api.getWeather()
outsideTemperature = weather["outsideTemperature"]["celsius"]
zones = {zone["name"]: zone["id"] for zone in api.getZones()}
for name in private.zones:
zone = zones[name]
state = api.getState(zone)
# create new table
with warnings.catch_warnings(), mysql.cursor() as cursor:
# temperatures are < 100 with up to two digits past the comma --> DECIMAL(4,2)
# percentages are <= 100 with only one digit past the comma --> DECIMAL(4,1)
sql = """
CREATE TABLE IF NOT EXISTS `{}` (
`timestamp` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
`outsideTemperature` DECIMAL(4,2),
`setpoint` DECIMAL(4,2),
`temperature` DECIMAL(4,2),
class TadoWrapper:
CONNECTION_RETRY_INTERVAL = 60
def __init__(self):
self.__t = None
self.__reconnect()
def __connect(self):
username, password = c.get_credentials()
self.__t = Tado(username, password)
def __reconnect(self):
connected = False
while not connected:
LoggingHelper.log("Trying to connect to Tado... ")
try:
self.__connect()
connected = True
LoggingHelper.log("Connection to Tado established.")
except r_exc.RequestException as e:
LoggingHelper.log(
"Connection to Tado failed. Trying again in {} seconds.".
format(TadoWrapper.CONNECTION_RETRY_INTERVAL))
LoggingHelper.log(e)
time.sleep(TadoWrapper.CONNECTION_RETRY_INTERVAL)
def get_zones(self):
data = self.__t.getZones()
return [{"id": d["id"], "name": d["name"]} for d in data]
def get_devices(self):
data = self.__t.getMobileDevices()
return [{
"name": d["name"],
"id": d["id"],
"geo_tracking": d["settings"]["geoTrackingEnabled"]
} for d in data]
def set_zone(self, zone, temperature):
success = False
while not success:
try:
self.__t.setZoneOverlay(zone=zone,
overlayMode="MANUAL",
setTemp=temperature)
success = True
LoggingHelper.log("Zone {} set to {} degrees.".format(
zone, temperature))
except r_exc.RequestException as e:
LoggingHelper.log("Unable to get device states.")
LoggingHelper.log(e)
self.__reconnect()
def reset_zone(self, zone):
success = False
while not success:
try:
self.__t.resetZoneOverlay(zone=zone)
success = True
LoggingHelper.log(
"Zone {} reset to tado schedule.".format(zone))
except r_exc.RequestException as e:
LoggingHelper.log("Unable to get device states.")
LoggingHelper.log(e)
self.__reconnect()
def get_device_athome_states(self):
success = False
data = None
while not success:
try:
data = self.__t.getMobileDevices()
if data is None:
raise TadoWrapperException(
"Mobile device data is None. Are any devices configured within Tado?"
)
success = True
except (r_exc.RequestException, TadoWrapperException) as e:
LoggingHelper.log("Unable to get device states.")
LoggingHelper.log(e)
self.__reconnect()
return {
d["name"]: {
"at_home": d["location"]["atHome"],
"stale": d["location"]["stale"]
}
for d in data if d is not None and "location" in d
}
def is_presence_locked(self):
success = False
data = None
result = False
while not success:
try:
data = self.__t.getHomeState()
if data == None:
raise TadoWrapperException(
"Mobile device data is None. Are any devices configured within Tado?"
)
success = True
except (r_exc.RequestException, TadoWrapperException) as e:
LoggingHelper.log("Unable to get device states.")
LoggingHelper.log(e)
self.__reconnect()
if "presenceLocked" in data:
result = data["presenceLocked"]
return result
