jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-04-24 09:17:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #10535 from broox/nuheat

Browse Source 
Adding a Nuheat Thermostat component
This commit is contained in:
Lukas Barth 2017-12-28 09:14:27 +01:00 committed by GitHub
commit fc3a8e4e79
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 566 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

233
homeassistant/components/climate/nuheat.py Normal file
View File

@ -0,0 +1,233 @@
"""
Support for NuHeat thermostats.
For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/climate.nuheat/
"""
import logging
from datetime import timedelta
from os import path
import voluptuous as vol
from homeassistant.components.climate import (
ClimateDevice,
DOMAIN,
SUPPORT_HOLD_MODE,
SUPPORT_OPERATION_MODE,
SUPPORT_TARGET_TEMPERATURE,
STATE_AUTO,
STATE_HEAT,
STATE_IDLE)
from homeassistant.components.nuheat import DOMAIN as NUHEAT_DOMAIN
from homeassistant.config import load_yaml_config_file
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_TEMPERATURE,
TEMP_CELSIUS,
TEMP_FAHRENHEIT)
import homeassistant.helpers.config_validation as cv
from homeassistant.util import Throttle
DEPENDENCIES = ["nuheat"]
_LOGGER = logging.getLogger(__name__)
ICON = "mdi:thermometer"
MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=5)
# Hold modes
MODE_AUTO = STATE_AUTO # Run device schedule
MODE_HOLD_TEMPERATURE = "temperature"
MODE_TEMPORARY_HOLD = "temporary_temperature"
OPERATION_LIST = [STATE_HEAT, STATE_IDLE]
SCHEDULE_HOLD = 3
SCHEDULE_RUN = 1
SCHEDULE_TEMPORARY_HOLD = 2
SERVICE_RESUME_PROGRAM = "nuheat_resume_program"
RESUME_PROGRAM_SCHEMA = vol.Schema({
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids
})
SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_HOLD_MODE |
SUPPORT_OPERATION_MODE)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the NuHeat thermostat(s)."""
if discovery_info is None:
return
temperature_unit = hass.config.units.temperature_unit
api, serial_numbers = hass.data[NUHEAT_DOMAIN]
thermostats = [
NuHeatThermostat(api, serial_number, temperature_unit)
for serial_number in serial_numbers
]
add_devices(thermostats, True)
def resume_program_set_service(service):
"""Resume the program on the target thermostats."""
entity_id = service.data.get(ATTR_ENTITY_ID)
if entity_id:
target_thermostats = [device for device in thermostats
if device.entity_id in entity_id]
else:
target_thermostats = thermostats
for thermostat in target_thermostats:
thermostat.resume_program()
thermostat.schedule_update_ha_state(True)
descriptions = load_yaml_config_file(
path.join(path.dirname(__file__), "services.yaml"))
hass.services.register(
DOMAIN, SERVICE_RESUME_PROGRAM, resume_program_set_service,
descriptions.get(SERVICE_RESUME_PROGRAM),
schema=RESUME_PROGRAM_SCHEMA)
class NuHeatThermostat(ClimateDevice):
"""Representation of a NuHeat Thermostat."""
def __init__(self, api, serial_number, temperature_unit):
"""Initialize the thermostat."""
self._thermostat = api.get_thermostat(serial_number)
self._temperature_unit = temperature_unit
self._force_update = False
@property
def name(self):
"""Return the name of the thermostat."""
return self._thermostat.room
@property
def icon(self):
"""Return the icon to use in the frontend."""
return ICON
@property
def supported_features(self):
"""Return the list of supported features."""
return SUPPORT_FLAGS
@property
def temperature_unit(self):
"""Return the unit of measurement."""
if self._temperature_unit == "C":
return TEMP_CELSIUS
return TEMP_FAHRENHEIT
@property
def current_temperature(self):
"""Return the current temperature."""
if self._temperature_unit == "C":
return self._thermostat.celsius
return self._thermostat.fahrenheit
@property
def current_operation(self):
"""Return current operation. ie. heat, idle."""
if self._thermostat.heating:
return STATE_HEAT
return STATE_IDLE
@property
def min_temp(self):
"""Return the minimum supported temperature for the thermostat."""
if self._temperature_unit == "C":
return self._thermostat.min_celsius
return self._thermostat.min_fahrenheit
@property
def max_temp(self):
"""Return the maximum supported temperature for the thermostat."""
if self._temperature_unit == "C":
return self._thermostat.max_celsius
return self._thermostat.max_fahrenheit
@property
def target_temperature(self):
"""Return the currently programmed temperature."""
if self._temperature_unit == "C":
return self._thermostat.target_celsius
return self._thermostat.target_fahrenheit
@property
def current_hold_mode(self):
"""Return current hold mode."""
schedule_mode = self._thermostat.schedule_mode
if schedule_mode == SCHEDULE_RUN:
return MODE_AUTO
if schedule_mode == SCHEDULE_HOLD:
return MODE_HOLD_TEMPERATURE
if schedule_mode == SCHEDULE_TEMPORARY_HOLD:
return MODE_TEMPORARY_HOLD
return MODE_AUTO
@property
def operation_list(self):
"""Return list of possible operation modes."""
return OPERATION_LIST
def resume_program(self):
"""Resume the thermostat's programmed schedule."""
self._thermostat.resume_schedule()
self._force_update = True
def set_hold_mode(self, hold_mode, **kwargs):
"""Update the hold mode of the thermostat."""
if hold_mode == MODE_AUTO:
schedule_mode = SCHEDULE_RUN
if hold_mode == MODE_HOLD_TEMPERATURE:
schedule_mode = SCHEDULE_HOLD
if hold_mode == MODE_TEMPORARY_HOLD:
schedule_mode = SCHEDULE_TEMPORARY_HOLD
self._thermostat.schedule_mode = schedule_mode
self._force_update = True
def set_temperature(self, **kwargs):
"""Set a new target temperature."""
temperature = kwargs.get(ATTR_TEMPERATURE)
if self._temperature_unit == "C":
self._thermostat.target_celsius = temperature
else:
self._thermostat.target_fahrenheit = temperature
_LOGGER.debug(
"Setting NuHeat thermostat temperature to %s %s",
temperature, self.temperature_unit)
self._force_update = True
def update(self):
"""Get the latest state from the thermostat."""
if self._force_update:
self._throttled_update(no_throttle=True)
self._force_update = False
else:
self._throttled_update()
@Throttle(MIN_TIME_BETWEEN_UPDATES)
def _throttled_update(self, **kwargs):
"""Get the latest state from the thermostat with a throttle."""
self._thermostat.get_data()

7
homeassistant/components/climate/services.yaml
View File

@ -100,3 +100,10 @@ ecobee_resume_program:
resume_all:
description: Resume all events and return to the scheduled program. This default to false which removes only the top event.
example: true
nuheat_resume_program:
description: Resume the programmed schedule.
fields:
entity_id:
description: Name(s) of entities to change.
example: 'climate.kitchen'

45
homeassistant/components/nuheat.py Normal file
View File

@ -0,0 +1,45 @@
"""
Support for NuHeat thermostats.
For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/nuheat/
"""
import logging
import voluptuous as vol
from homeassistant.const import CONF_USERNAME, CONF_PASSWORD, CONF_DEVICES
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers import discovery
REQUIREMENTS = ["nuheat==0.3.0"]
_LOGGER = logging.getLogger(__name__)
DOMAIN = "nuheat"
CONFIG_SCHEMA = vol.Schema({
DOMAIN: vol.Schema({
vol.Required(CONF_USERNAME): cv.string,
vol.Required(CONF_PASSWORD): cv.string,
vol.Required(CONF_DEVICES, default=[]):
vol.All(cv.ensure_list, [cv.string]),
}),
}, extra=vol.ALLOW_EXTRA)
def setup(hass, config):
"""Set up the NuHeat thermostat component."""
import nuheat
conf = config[DOMAIN]
username = conf.get(CONF_USERNAME)
password = conf.get(CONF_PASSWORD)
devices = conf.get(CONF_DEVICES)
api = nuheat.NuHeat(username, password)
api.authenticate()
hass.data[DOMAIN] = (api, devices)
discovery.load_platform(hass, "climate", DOMAIN, {}, config)
return True

3
requirements_all.txt
View File

@ -500,6 +500,9 @@ neurio==0.3.1
# homeassistant.components.sensor.nederlandse_spoorwegen
nsapi==2.7.4
# homeassistant.components.nuheat
nuheat==0.3.0
# homeassistant.components.binary_sensor.trend
# homeassistant.components.image_processing.opencv
numpy==1.13.3

232
tests/components/climate/test_nuheat.py Normal file
View File

@ -0,0 +1,232 @@
"""The test for the NuHeat thermostat module."""
import unittest
from unittest.mock import Mock, patch
from tests.common import get_test_home_assistant
from homeassistant.components.climate import (
SUPPORT_HOLD_MODE,
SUPPORT_OPERATION_MODE,
SUPPORT_TARGET_TEMPERATURE,
STATE_HEAT,
STATE_IDLE)
import homeassistant.components.climate.nuheat as nuheat
from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
SCHEDULE_HOLD = 3
SCHEDULE_RUN = 1
SCHEDULE_TEMPORARY_HOLD = 2
class TestNuHeat(unittest.TestCase):
"""Tests for NuHeat climate."""
# pylint: disable=protected-access, no-self-use
def setUp(self): # pylint: disable=invalid-name
"""Set up test variables."""
serial_number = "12345"
temperature_unit = "F"
thermostat = Mock(
serial_number=serial_number,
room="Master bathroom",
online=True,
heating=True,
temperature=2222,
celsius=22,
fahrenheit=72,
max_celsius=69,
max_fahrenheit=157,
min_celsius=5,
min_fahrenheit=41,
schedule_mode=SCHEDULE_RUN,
target_celsius=22,
target_fahrenheit=72)
thermostat.get_data = Mock()
thermostat.resume_schedule = Mock()
self.api = Mock()
self.api.get_thermostat.return_value = thermostat
self.hass = get_test_home_assistant()
self.thermostat = nuheat.NuHeatThermostat(
self.api, serial_number, temperature_unit)
def tearDown(self): # pylint: disable=invalid-name
"""Stop hass."""
self.hass.stop()
@patch("homeassistant.components.climate.nuheat.NuHeatThermostat")
def test_setup_platform(self, mocked_thermostat):
"""Test setup_platform."""
mocked_thermostat.return_value = self.thermostat
thermostat = mocked_thermostat(self.api, "12345", "F")
thermostats = [thermostat]
self.hass.data[nuheat.NUHEAT_DOMAIN] = (self.api, ["12345"])
config = {}
add_devices = Mock()
discovery_info = {}
nuheat.setup_platform(self.hass, config, add_devices, discovery_info)
add_devices.assert_called_once_with(thermostats, True)
@patch("homeassistant.components.climate.nuheat.NuHeatThermostat")
def test_resume_program_service(self, mocked_thermostat):
"""Test resume program service."""
mocked_thermostat.return_value = self.thermostat
thermostat = mocked_thermostat(self.api, "12345", "F")
thermostat.resume_program = Mock()
thermostat.schedule_update_ha_state = Mock()
thermostat.entity_id = "climate.master_bathroom"
self.hass.data[nuheat.NUHEAT_DOMAIN] = (self.api, ["12345"])
nuheat.setup_platform(self.hass, {}, Mock(), {})
# Explicit entity
self.hass.services.call(nuheat.DOMAIN, nuheat.SERVICE_RESUME_PROGRAM,
{"entity_id": "climate.master_bathroom"}, True)
thermostat.resume_program.assert_called_with()
thermostat.schedule_update_ha_state.assert_called_with(True)
thermostat.resume_program.reset_mock()
thermostat.schedule_update_ha_state.reset_mock()
# All entities
self.hass.services.call(
nuheat.DOMAIN, nuheat.SERVICE_RESUME_PROGRAM, {}, True)
thermostat.resume_program.assert_called_with()
thermostat.schedule_update_ha_state.assert_called_with(True)
def test_name(self):
"""Test name property."""
self.assertEqual(self.thermostat.name, "Master bathroom")
def test_icon(self):
"""Test name property."""
self.assertEqual(self.thermostat.icon, "mdi:thermometer")
def test_supported_features(self):
"""Test name property."""
features = (SUPPORT_TARGET_TEMPERATURE | SUPPORT_HOLD_MODE |
SUPPORT_OPERATION_MODE)
self.assertEqual(self.thermostat.supported_features, features)
def test_temperature_unit(self):
"""Test temperature unit."""
self.assertEqual(self.thermostat.temperature_unit, TEMP_FAHRENHEIT)
self.thermostat._temperature_unit = "C"
self.assertEqual(self.thermostat.temperature_unit, TEMP_CELSIUS)
def test_current_temperature(self):
"""Test current temperature."""
self.assertEqual(self.thermostat.current_temperature, 72)
self.thermostat._temperature_unit = "C"
self.assertEqual(self.thermostat.current_temperature, 22)
def test_current_operation(self):
"""Test current operation."""
self.assertEqual(self.thermostat.current_operation, STATE_HEAT)
self.thermostat._thermostat.heating = False
self.assertEqual(self.thermostat.current_operation, STATE_IDLE)
def test_min_temp(self):
"""Test min temp."""
self.assertEqual(self.thermostat.min_temp, 41)
self.thermostat._temperature_unit = "C"
self.assertEqual(self.thermostat.min_temp, 5)
def test_max_temp(self):
"""Test max temp."""
self.assertEqual(self.thermostat.max_temp, 157)
self.thermostat._temperature_unit = "C"
self.assertEqual(self.thermostat.max_temp, 69)
def test_target_temperature(self):
"""Test target temperature."""
self.assertEqual(self.thermostat.target_temperature, 72)
self.thermostat._temperature_unit = "C"
self.assertEqual(self.thermostat.target_temperature, 22)
def test_current_hold_mode(self):
"""Test current hold mode."""
self.thermostat._thermostat.schedule_mode = SCHEDULE_RUN
self.assertEqual(self.thermostat.current_hold_mode, nuheat.MODE_AUTO)
self.thermostat._thermostat.schedule_mode = SCHEDULE_HOLD
self.assertEqual(
self.thermostat.current_hold_mode, nuheat.MODE_HOLD_TEMPERATURE)
self.thermostat._thermostat.schedule_mode = SCHEDULE_TEMPORARY_HOLD
self.assertEqual(
self.thermostat.current_hold_mode, nuheat.MODE_TEMPORARY_HOLD)
self.thermostat._thermostat.schedule_mode = None
self.assertEqual(
self.thermostat.current_hold_mode, nuheat.MODE_AUTO)
def test_operation_list(self):
"""Test the operation list."""
self.assertEqual(
self.thermostat.operation_list,
[STATE_HEAT, STATE_IDLE]
)
def test_resume_program(self):
"""Test resume schedule."""
self.thermostat.resume_program()
self.thermostat._thermostat.resume_schedule.assert_called_once_with()
self.assertTrue(self.thermostat._force_update)
def test_set_hold_mode(self):
"""Test set hold mode."""
self.thermostat.set_hold_mode("temperature")
self.assertEqual(
self.thermostat._thermostat.schedule_mode, SCHEDULE_HOLD)
self.assertTrue(self.thermostat._force_update)
self.thermostat.set_hold_mode("temporary_temperature")
self.assertEqual(
self.thermostat._thermostat.schedule_mode, SCHEDULE_TEMPORARY_HOLD)
self.assertTrue(self.thermostat._force_update)
self.thermostat.set_hold_mode("auto")
self.assertEqual(
self.thermostat._thermostat.schedule_mode, SCHEDULE_RUN)
self.assertTrue(self.thermostat._force_update)
def test_set_temperature(self):
"""Test set temperature."""
self.thermostat.set_temperature(temperature=85)
self.assertEqual(self.thermostat._thermostat.target_fahrenheit, 85)
self.assertTrue(self.thermostat._force_update)
self.thermostat._temperature_unit = "C"
self.thermostat.set_temperature(temperature=23)
self.assertEqual(self.thermostat._thermostat.target_celsius, 23)
self.assertTrue(self.thermostat._force_update)
@patch.object(nuheat.NuHeatThermostat, "_throttled_update")
def test_update_without_throttle(self, throttled_update):
"""Test update without throttle."""
self.thermostat._force_update = True
self.thermostat.update()
throttled_update.assert_called_once_with(no_throttle=True)
self.assertFalse(self.thermostat._force_update)
@patch.object(nuheat.NuHeatThermostat, "_throttled_update")
def test_update_with_throttle(self, throttled_update):
"""Test update with throttle."""
self.thermostat._force_update = False
self.thermostat.update()
throttled_update.assert_called_once_with()
self.assertFalse(self.thermostat._force_update)
def test_throttled_update(self):
"""Test update with throttle."""
self.thermostat._throttled_update()
self.thermostat._thermostat.get_data.assert_called_once_with()

46
tests/components/test_nuheat.py Normal file
View File

@ -0,0 +1,46 @@
"""NuHeat component tests."""
import unittest
from unittest.mock import patch
from tests.common import get_test_home_assistant, MockDependency
from homeassistant.components import nuheat
VALID_CONFIG = {
"nuheat": {
"username": "warm",
"password": "feet",
"devices": "thermostat123"
}
}
class TestNuHeat(unittest.TestCase):
"""Test the NuHeat component."""
def setUp(self): # pylint: disable=invalid-name
"""Initialize the values for this test class."""
self.hass = get_test_home_assistant()
self.config = VALID_CONFIG
def tearDown(self): # pylint: disable=invalid-name
"""Teardown this test class. Stop hass."""
self.hass.stop()
@MockDependency("nuheat")
@patch("homeassistant.helpers.discovery.load_platform")
def test_setup(self, mocked_nuheat, mocked_load):
"""Test setting up the NuHeat component."""
nuheat.setup(self.hass, self.config)
mocked_nuheat.NuHeat.assert_called_with("warm", "feet")
self.assertIn(nuheat.DOMAIN, self.hass.data)
self.assertEquals(2, len(self.hass.data[nuheat.DOMAIN]))
self.assertIsInstance(
self.hass.data[nuheat.DOMAIN][0], type(mocked_nuheat.NuHeat())
)
self.assertEquals(self.hass.data[nuheat.DOMAIN][1], "thermostat123")
mocked_load.assert_called_with(
self.hass, "climate", nuheat.DOMAIN, {}, self.config
)