evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add support for percentage speeds and preset modes to template fan (#45478)

Browse source
This commit is contained in:
J. Nick Koston 2021-01-28 03:44:36 -06:00 • committed by GitHub
parent 22e44e4ba4
commit babfef829d
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 493 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

218
homeassistant/components/template/fan.py
View file

@ -6,6 +6,8 @@ import voluptuous as vol
from homeassistant.components.fan import (
ATTR_DIRECTION,
ATTR_OSCILLATING,
ATTR_PERCENTAGE,
ATTR_PRESET_MODE,
ATTR_SPEED,
DIRECTION_FORWARD,
DIRECTION_REVERSE,
@ -13,10 +15,12 @@ from homeassistant.components.fan import (
SPEED_HIGH,
SPEED_LOW,
SPEED_MEDIUM,
SPEED_OFF,
SUPPORT_DIRECTION,
SUPPORT_OSCILLATE,
SUPPORT_SET_SPEED,
FanEntity,
preset_modes_from_speed_list,
)
from homeassistant.const import (
CONF_ENTITY_ID,
@ -42,14 +46,19 @@ _LOGGER = logging.getLogger(__name__)
CONF_FANS = "fans"
CONF_SPEED_LIST = "speeds"
CONF_PRESET_MODES = "preset_modes"
CONF_SPEED_TEMPLATE = "speed_template"
CONF_PERCENTAGE_TEMPLATE = "percentage_template"
CONF_PRESET_MODE_TEMPLATE = "preset_mode_template"
CONF_OSCILLATING_TEMPLATE = "oscillating_template"
CONF_DIRECTION_TEMPLATE = "direction_template"
CONF_ON_ACTION = "turn_on"
CONF_OFF_ACTION = "turn_off"
CONF_SET_PERCENTAGE_ACTION = "set_percentage"
CONF_SET_SPEED_ACTION = "set_speed"
CONF_SET_OSCILLATING_ACTION = "set_oscillating"
CONF_SET_DIRECTION_ACTION = "set_direction"
CONF_SET_PRESET_MODE_ACTION = "set_preset_mode"
_VALID_STATES = [STATE_ON, STATE_OFF]
_VALID_OSC = [True, False]
@ -57,22 +66,31 @@ _VALID_DIRECTIONS = [DIRECTION_FORWARD, DIRECTION_REVERSE]
FAN_SCHEMA = vol.All(
cv.deprecated(CONF_ENTITY_ID),
cv.deprecated(CONF_SPEED_LIST),
cv.deprecated(CONF_SPEED_TEMPLATE),
cv.deprecated(CONF_SET_SPEED_ACTION),
vol.Schema(
{
vol.Optional(CONF_FRIENDLY_NAME): cv.string,
vol.Required(CONF_VALUE_TEMPLATE): cv.template,
vol.Optional(CONF_SPEED_TEMPLATE): cv.template,
vol.Optional(CONF_PERCENTAGE_TEMPLATE): cv.template,
vol.Optional(CONF_PRESET_MODE_TEMPLATE): cv.template,
vol.Optional(CONF_OSCILLATING_TEMPLATE): cv.template,
vol.Optional(CONF_DIRECTION_TEMPLATE): cv.template,
vol.Optional(CONF_AVAILABILITY_TEMPLATE): cv.template,
vol.Required(CONF_ON_ACTION): cv.SCRIPT_SCHEMA,
vol.Required(CONF_OFF_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_SET_SPEED_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_SET_PERCENTAGE_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_SET_PRESET_MODE_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_SET_OSCILLATING_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_SET_DIRECTION_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(
CONF_SPEED_LIST, default=[SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH]
CONF_SPEED_LIST,
default=[SPEED_OFF, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH],
): cv.ensure_list,
vol.Optional(CONF_PRESET_MODES): cv.ensure_list,
vol.Optional(CONF_ENTITY_ID): cv.entity_ids,
vol.Optional(CONF_UNIQUE_ID): cv.string,
}
@ -93,6 +111,8 @@ async def _async_create_entities(hass, config):
state_template = device_config[CONF_VALUE_TEMPLATE]
speed_template = device_config.get(CONF_SPEED_TEMPLATE)
percentage_template = device_config.get(CONF_PERCENTAGE_TEMPLATE)
preset_mode_template = device_config.get(CONF_PRESET_MODE_TEMPLATE)
oscillating_template = device_config.get(CONF_OSCILLATING_TEMPLATE)
direction_template = device_config.get(CONF_DIRECTION_TEMPLATE)
availability_template = device_config.get(CONF_AVAILABILITY_TEMPLATE)
@ -100,10 +120,13 @@ async def _async_create_entities(hass, config):
on_action = device_config[CONF_ON_ACTION]
off_action = device_config[CONF_OFF_ACTION]
set_speed_action = device_config.get(CONF_SET_SPEED_ACTION)
set_percentage_action = device_config.get(CONF_SET_PERCENTAGE_ACTION)
set_preset_mode_action = device_config.get(CONF_SET_PRESET_MODE_ACTION)
set_oscillating_action = device_config.get(CONF_SET_OSCILLATING_ACTION)
set_direction_action = device_config.get(CONF_SET_DIRECTION_ACTION)
speed_list = device_config[CONF_SPEED_LIST]
preset_modes = device_config.get(CONF_PRESET_MODES)
unique_id = device_config.get(CONF_UNIQUE_ID)
fans.append(
@ -113,15 +136,20 @@ async def _async_create_entities(hass, config):
friendly_name,
state_template,
speed_template,
percentage_template,
preset_mode_template,
oscillating_template,
direction_template,
availability_template,
on_action,
off_action,
set_speed_action,
set_percentage_action,
set_preset_mode_action,
set_oscillating_action,
set_direction_action,
speed_list,
preset_modes,
unique_id,
)
)
@ -146,15 +174,20 @@ class TemplateFan(TemplateEntity, FanEntity):
friendly_name,
state_template,
speed_template,
percentage_template,
preset_mode_template,
oscillating_template,
direction_template,
availability_template,
on_action,
off_action,
set_speed_action,
set_percentage_action,
set_preset_mode_action,
set_oscillating_action,
set_direction_action,
speed_list,
preset_modes,
unique_id,
):
"""Initialize the fan."""
@ -167,6 +200,8 @@ class TemplateFan(TemplateEntity, FanEntity):
self._template = state_template
self._speed_template = speed_template
self._percentage_template = percentage_template
self._preset_mode_template = preset_mode_template
self._oscillating_template = oscillating_template
self._direction_template = direction_template
self._supported_features = 0
@ -182,6 +217,18 @@ class TemplateFan(TemplateEntity, FanEntity):
hass, set_speed_action, friendly_name, domain
)
self._set_percentage_script = None
if set_percentage_action:
self._set_percentage_script = Script(
hass, set_percentage_action, friendly_name, domain
)
self._set_preset_mode_script = None
if set_preset_mode_action:
self._set_preset_mode_script = Script(
hass, set_preset_mode_action, friendly_name, domain
)
self._set_oscillating_script = None
if set_oscillating_action:
self._set_oscillating_script = Script(
@ -196,10 +243,16 @@ class TemplateFan(TemplateEntity, FanEntity):
self._state = STATE_OFF
self._speed = None
self._percentage = None
self._preset_mode = None
self._oscillating = None
self._direction = None
if self._speed_template:
if (
self._speed_template
or self._percentage_template
or self._preset_mode_template
):
self._supported_features |= SUPPORT_SET_SPEED
if self._oscillating_template:
self._supported_features |= SUPPORT_OSCILLATE
@ -211,6 +264,9 @@ class TemplateFan(TemplateEntity, FanEntity):
# List of valid speeds
self._speed_list = speed_list
# List of valid preset modes
self._preset_modes = preset_modes
@property
def name(self):
"""Return the display name of this fan."""
@ -231,6 +287,13 @@ class TemplateFan(TemplateEntity, FanEntity):
"""Get the list of available speeds."""
return self._speed_list
@property
def preset_modes(self) -> list:
"""Get the list of available preset modes."""
if self._preset_modes is not None:
return self._preset_modes
return preset_modes_from_speed_list(self._speed_list)
@property
def is_on(self):
"""Return true if device is on."""
@ -241,6 +304,16 @@ class TemplateFan(TemplateEntity, FanEntity):
"""Return the current speed."""
return self._speed
@property
def preset_mode(self):
"""Return the current preset mode."""
return self._preset_mode
@property
def percentage(self):
"""Return the current speed percentage."""
return self._percentage
@property
def oscillating(self):
"""Return the oscillation state."""
@ -251,13 +324,6 @@ class TemplateFan(TemplateEntity, FanEntity):
"""Return the oscillation state."""
return self._direction
#
# The fan entity model has changed to use percentages and preset_modes
# instead of speeds.
#
# Please review
# https://developers.home-assistant.io/docs/core/entity/fan/
#
async def async_turn_on(
self,
speed: str = None,
@ -266,10 +332,21 @@ class TemplateFan(TemplateEntity, FanEntity):
**kwargs,
) -> None:
"""Turn on the fan."""
await self._on_script.async_run({ATTR_SPEED: speed}, context=self._context)
await self._on_script.async_run(
{
ATTR_SPEED: speed,
ATTR_PERCENTAGE: percentage,
ATTR_PRESET_MODE: preset_mode,
},
context=self._context,
)
self._state = STATE_ON
if speed is not None:
if preset_mode is not None:
await self.async_set_preset_mode(preset_mode)
elif percentage is not None:
await self.async_set_percentage(percentage)
elif speed is not None:
await self.async_set_speed(speed)
# pylint: disable=arguments-differ
@ -280,17 +357,53 @@ class TemplateFan(TemplateEntity, FanEntity):
async def async_set_speed(self, speed: str) -> None:
"""Set the speed of the fan."""
if self._set_speed_script is None:
if speed not in self.speed_list:
_LOGGER.error(
"Received invalid speed: %s. Expected: %s", speed, self.speed_list
)
return
if speed in self._speed_list:
self._speed = speed
self._state = STATE_OFF if speed == SPEED_OFF else STATE_ON
self._speed = speed
self._preset_mode = None
self._percentage = self.speed_to_percentage(speed)
if self._set_speed_script:
await self._set_speed_script.async_run(
{ATTR_SPEED: speed}, context=self._context
{ATTR_SPEED: self._speed}, context=self._context
)
else:
async def async_set_percentage(self, percentage: int) -> None:
"""Set the percentage speed of the fan."""
speed_list = self.speed_list
self._state = STATE_OFF if percentage == 0 else STATE_ON
self._speed = self.percentage_to_speed(percentage) if speed_list else None
self._percentage = percentage
self._preset_mode = None
if self._set_percentage_script:
await self._set_percentage_script.async_run(
{ATTR_PERCENTAGE: self._percentage}, context=self._context
)
async def async_set_preset_mode(self, preset_mode: str) -> None:
"""Set the preset_mode of the fan."""
if preset_mode not in self.preset_modes:
_LOGGER.error(
"Received invalid speed: %s. Expected: %s", speed, self._speed_list
"Received invalid preset_mode: %s. Expected: %s",
preset_mode,
self.preset_modes,
)
return
self._state = STATE_ON
self._preset_mode = preset_mode
self._speed = preset_mode
self._percentage = None
if self._set_preset_mode_script:
await self._set_preset_mode_script.async_run(
{ATTR_PRESET_MODE: self._preset_mode}, context=self._context
)
async def async_oscillate(self, oscillating: bool) -> None:
@ -350,6 +463,22 @@ class TemplateFan(TemplateEntity, FanEntity):
async def async_added_to_hass(self):
"""Register callbacks."""
self.add_template_attribute("_state", self._template, None, self._update_state)
if self._preset_mode_template is not None:
self.add_template_attribute(
"_preset_mode",
self._preset_mode_template,
None,
self._update_preset_mode,
none_on_template_error=True,
)
if self._percentage_template is not None:
self.add_template_attribute(
"_percentage",
self._percentage_template,
None,
self._update_percentage,
none_on_template_error=True,
)
if self._speed_template is not None:
self.add_template_attribute(
"_speed",
@ -382,14 +511,69 @@ class TemplateFan(TemplateEntity, FanEntity):
speed = str(speed)
if speed in self._speed_list:
self._state = STATE_OFF if speed == SPEED_OFF else STATE_ON
self._speed = speed
self._percentage = self.speed_to_percentage(speed)
self._preset_mode = speed if speed in self.preset_modes else None
elif speed in [STATE_UNAVAILABLE, STATE_UNKNOWN]:
self._speed = None
self._percentage = 0
self._preset_mode = None
else:
_LOGGER.error(
"Received invalid speed: %s. Expected: %s", speed, self._speed_list
)
self._speed = None
self._percentage = 0
self._preset_mode = None
@callback
def _update_percentage(self, percentage):
# Validate percentage
try:
percentage = int(float(percentage))
except ValueError:
_LOGGER.error("Received invalid percentage: %s", percentage)
self._speed = None
self._percentage = 0
self._preset_mode = None
return
if 0 <= percentage <= 100:
self._state = STATE_OFF if percentage == 0 else STATE_ON
self._percentage = percentage
if self._speed_list:
self._speed = self.percentage_to_speed(percentage)
self._preset_mode = None
else:
_LOGGER.error("Received invalid percentage: %s", percentage)
self._speed = None
self._percentage = 0
self._preset_mode = None
@callback
def _update_preset_mode(self, preset_mode):
# Validate preset mode
preset_mode = str(preset_mode)
if preset_mode in self.preset_modes:
self._state = STATE_ON
self._speed = preset_mode
self._percentage = None
self._preset_mode = preset_mode
elif preset_mode in [STATE_UNAVAILABLE, STATE_UNKNOWN]:
self._speed = None
self._percentage = None
self._preset_mode = None
else:
_LOGGER.error(
"Received invalid preset_mode: %s. Expected: %s",
preset_mode,
self.preset_mode,
)
self._speed = None
self._percentage = None
self._preset_mode = None
@callback
def _update_oscillating(self, oscillating):