Climate 1.0

homeassistant/components/alexa/capabilities.py

@@ -23,6 +23,7 @@
 from .const import (
     API_TEMP_UNITS,
     API_THERMOSTAT_MODES,
+    API_THERMOSTAT_PRESETS,
     DATE_FORMAT,
     PERCENTAGE_FAN_MAP,
 )
@@ -180,9 +181,13 @@ def get_property(self, name):
         if name != 'powerState':
             raise UnsupportedProperty(name)
 
-        if self.entity.state == STATE_OFF:
-            return 'OFF'
-        return 'ON'
+        if self.entity.domain == climate.DOMAIN:
+            is_on = self.entity.state != climate.HVAC_MODE_OFF
+
+        else:
+            is_on = self.entity.state != STATE_OFF
+
+        return 'ON' if is_on else 'OFF'
 
 
 class AlexaLockController(AlexaCapibility):
@@ -546,16 +551,13 @@ def name(self):
 
     def properties_supported(self):
         """Return what properties this entity supports."""
-        properties = []
+        properties = [{'name': 'thermostatMode'}]
         supported = self.entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
         if supported & climate.SUPPORT_TARGET_TEMPERATURE:
             properties.append({'name': 'targetSetpoint'})
-        if supported & climate.SUPPORT_TARGET_TEMPERATURE_LOW:
+        if supported & climate.SUPPORT_TARGET_TEMPERATURE_RANGE:
             properties.append({'name': 'lowerSetpoint'})
-        if supported & climate.SUPPORT_TARGET_TEMPERATURE_HIGH:
             properties.append({'name': 'upperSetpoint'})
-        if supported & climate.SUPPORT_OPERATION_MODE:
-            properties.append({'name': 'thermostatMode'})
         return properties
 
     def properties_proactively_reported(self):
@@ -569,13 +571,18 @@ def properties_retrievable(self):
     def get_property(self, name):
         """Read and return a property."""
         if name == 'thermostatMode':
-            ha_mode = self.entity.attributes.get(climate.ATTR_OPERATION_MODE)
-            mode = API_THERMOSTAT_MODES.get(ha_mode)
-            if mode is None:
-                _LOGGER.error("%s (%s) has unsupported %s value '%s'",
-                              self.entity.entity_id, type(self.entity),
-                              climate.ATTR_OPERATION_MODE, ha_mode)
-                raise UnsupportedProperty(name)
+            preset = self.entity.attributes.get(climate.ATTR_PRESET_MODE)
+
+            if preset in API_THERMOSTAT_PRESETS:
+                mode = API_THERMOSTAT_PRESETS[preset]
+            else:
+                mode = API_THERMOSTAT_MODES.get(self.entity.state)
+                if mode is None:
+                    _LOGGER.error(
+                        "%s (%s) has unsupported state value '%s'",
+                        self.entity.entity_id, type(self.entity),
+                        self.entity.state)
+                    raise UnsupportedProperty(name)
             return mode
 
         unit = self.hass.config.units.temperature_unit

homeassistant/components/alexa/const.py

@@ -2,7 +2,6 @@
 from collections import OrderedDict
 
 from homeassistant.const import (
-    STATE_OFF,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
 )
@@ -57,16 +56,17 @@
 # reverse mapping of this dict and we want to map the first occurrance of OFF
 # back to HA state.
 API_THERMOSTAT_MODES = OrderedDict([
-    (climate.STATE_HEAT, 'HEAT'),
-    (climate.STATE_COOL, 'COOL'),
-    (climate.STATE_AUTO, 'AUTO'),
-    (climate.STATE_ECO, 'ECO'),
-    (climate.STATE_MANUAL, 'AUTO'),
-    (STATE_OFF, 'OFF'),
-    (climate.STATE_IDLE, 'OFF'),
-    (climate.STATE_FAN_ONLY, 'OFF'),
-    (climate.STATE_DRY, 'OFF'),
+    (climate.HVAC_MODE_HEAT, 'HEAT'),
+    (climate.HVAC_MODE_COOL, 'COOL'),
+    (climate.HVAC_MODE_HEAT_COOL, 'AUTO'),
+    (climate.HVAC_MODE_AUTO, 'AUTO'),
+    (climate.HVAC_MODE_OFF, 'OFF'),
+    (climate.HVAC_MODE_FAN_ONLY, 'OFF'),
+    (climate.HVAC_MODE_DRY, 'OFF'),
 ])
+API_THERMOSTAT_PRESETS = {
+    climate.PRESET_ECO: 'ECO'
+}
 
 PERCENTAGE_FAN_MAP = {
     fan.SPEED_LOW: 33,

homeassistant/components/alexa/entities.py

@@ -248,9 +248,11 @@ def default_display_categories(self):
 
     def interfaces(self):
         """Yield the supported interfaces."""
-        supported = self.entity.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
-        if supported & climate.SUPPORT_ON_OFF:
+        # If we support two modes, one being off, we allow turning on too.
+        if len([v for v in self.entity.attributes[climate.ATTR_HVAC_MODES]
+                if v != climate.HVAC_MODE_OFF]) == 1:
             yield AlexaPowerController(self.entity)
+
         yield AlexaThermostatController(self.hass, self.entity)
         yield AlexaTemperatureSensor(self.hass, self.entity)
         yield AlexaEndpointHealth(self.hass, self.entity)

homeassistant/components/alexa/handlers.py

@@ -33,6 +33,7 @@
 from .const import (
     API_TEMP_UNITS,
     API_THERMOSTAT_MODES,
+    API_THERMOSTAT_PRESETS,
     Cause,
 )
 from .entities import async_get_entities
@@ -686,23 +687,45 @@ async def async_api_set_thermostat_mode(hass, config, directive, context):
     mode = directive.payload['thermostatMode']
     mode = mode if isinstance(mode, str) else mode['value']
 
-    operation_list = entity.attributes.get(climate.ATTR_OPERATION_LIST)
-    ha_mode = next(
-        (k for k, v in API_THERMOSTAT_MODES.items() if v == mode),
-        None
-    )
-    if ha_mode not in operation_list:
-        msg = 'The requested thermostat mode {} is not supported'.format(mode)
-        raise AlexaUnsupportedThermostatModeError(msg)
-
     data = {
         ATTR_ENTITY_ID: entity.entity_id,
-        climate.ATTR_OPERATION_MODE: ha_mode,
     }
 
+    ha_preset = next(
+        (k for k, v in API_THERMOSTAT_PRESETS.items() if v == mode),
+        None
+    )
+
+    if ha_preset:
+        presets = entity.attributes.get(climate.ATTR_PRESET_MODES, [])
+
+        if ha_preset not in presets:
+            msg = 'The requested thermostat mode {} is not supported'.format(
+                ha_preset
+            )
+            raise AlexaUnsupportedThermostatModeError(msg)
+
+        service = climate.SERVICE_SET_PRESET_MODE
+        data[climate.ATTR_PRESET_MODE] = climate.PRESET_ECO
+
+    else:
+        operation_list = entity.attributes.get(climate.ATTR_HVAC_MODES)
+        ha_mode = next(
+            (k for k, v in API_THERMOSTAT_MODES.items() if v == mode),
+            None
+        )
+        if ha_mode not in operation_list:
+            msg = 'The requested thermostat mode {} is not supported'.format(
+                mode
+            )
+            raise AlexaUnsupportedThermostatModeError(msg)
+
+        service = climate.SERVICE_SET_HVAC_MODE
+        data[climate.ATTR_HVAC_MODE] = ha_mode
+
     response = directive.response()
     await hass.services.async_call(
-        entity.domain, climate.SERVICE_SET_OPERATION_MODE, data,
+        climate.DOMAIN, service, data,
         blocking=False, context=context)
     response.add_context_property({
         'name': 'thermostatMode',

homeassistant/components/ambiclimate/climate.py

@@ -7,11 +7,8 @@
 
 from homeassistant.components.climate import ClimateDevice
 from homeassistant.components.climate.const import (
-    SUPPORT_TARGET_TEMPERATURE,
-    SUPPORT_ON_OFF, STATE_HEAT)
-from homeassistant.const import ATTR_NAME
-from homeassistant.const import (ATTR_TEMPERATURE,
-                                 STATE_OFF, TEMP_CELSIUS)
+    SUPPORT_TARGET_TEMPERATURE, HVAC_MODE_OFF, HVAC_MODE_HEAT)
+from homeassistant.const import ATTR_NAME, ATTR_TEMPERATURE, TEMP_CELSIUS
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from .const import (ATTR_VALUE, CONF_CLIENT_ID, CONF_CLIENT_SECRET,
@@ -20,8 +17,7 @@
 
 _LOGGER = logging.getLogger(__name__)
 
-SUPPORT_FLAGS = (SUPPORT_TARGET_TEMPERATURE |
-                 SUPPORT_ON_OFF)
+SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE
 
 SEND_COMFORT_FEEDBACK_SCHEMA = vol.Schema({
     vol.Required(ATTR_NAME): cv.string,
@@ -177,11 +173,6 @@ def current_humidity(self):
         """Return the current humidity."""
         return self._data.get('humidity')
 
-    @property
-    def is_on(self):
-        """Return true if heater is on."""
-        return self._data.get('power', '').lower() == 'on'
-
     @property
     def min_temp(self):
         """Return the minimum temperature."""
@@ -198,9 +189,12 @@ def supported_features(self):
         return SUPPORT_FLAGS
 
     @property
-    def current_operation(self):
+    def hvac_mode(self):
         """Return current operation."""
-        return STATE_HEAT if self.is_on else STATE_OFF
+        if self._data.get('power', '').lower() == 'on':
+            return HVAC_MODE_HEAT
+
+        return HVAC_MODE_OFF
 
     async def async_set_temperature(self, **kwargs):
         """Set new target temperature."""
@@ -209,13 +203,13 @@ async def async_set_temperature(self, **kwargs):
             return
         await self._heater.set_target_temperature(temperature)
 
-    async def async_turn_on(self):
-        """Turn device on."""
-        await self._heater.turn_on()
-
-    async def async_turn_off(self):
-        """Turn device off."""
-        await self._heater.turn_off()
+    async def async_set_hvac_mode(self, hvac_mode):
+        """Set new target hvac mode."""
+        if hvac_mode == HVAC_MODE_HEAT:
+            await self._heater.turn_on()
+            return
+        if hvac_mode == HVAC_MODE_OFF:
+            await self._heater.turn_off()
 
     async def async_update(self):
         """Retrieve latest state."""