141 lines
3.8 KiB
Python
141 lines
3.8 KiB
Python
"""
|
|
homeassistant.components.input_select
|
|
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
Component to offer a way to select an option from a list.
|
|
|
|
For more details about this component, please refer to the documentation
|
|
at https://home-assistant.io/components/input_select/
|
|
"""
|
|
import logging
|
|
|
|
from homeassistant.const import ATTR_ENTITY_ID
|
|
from homeassistant.helpers.entity_component import EntityComponent
|
|
from homeassistant.helpers.entity import Entity
|
|
from homeassistant.util import slugify
|
|
|
|
DOMAIN = 'input_select'
|
|
ENTITY_ID_FORMAT = DOMAIN + '.{}'
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
CONF_NAME = 'name'
|
|
CONF_INITIAL = 'initial'
|
|
CONF_ICON = 'icon'
|
|
CONF_OPTIONS = 'options'
|
|
|
|
ATTR_OPTION = 'option'
|
|
ATTR_OPTIONS = 'options'
|
|
|
|
SERVICE_SELECT_OPTION = 'select_option'
|
|
|
|
|
|
def select_option(hass, entity_id, option):
|
|
""" Set input_select to False. """
|
|
hass.services.call(DOMAIN, SERVICE_SELECT_OPTION, {
|
|
ATTR_ENTITY_ID: entity_id,
|
|
ATTR_OPTION: option,
|
|
})
|
|
|
|
|
|
def setup(hass, config):
|
|
""" Set up input select. """
|
|
if not isinstance(config.get(DOMAIN), dict):
|
|
_LOGGER.error('Expected %s config to be a dictionary', DOMAIN)
|
|
return False
|
|
|
|
component = EntityComponent(_LOGGER, DOMAIN, hass)
|
|
|
|
entities = []
|
|
|
|
for object_id, cfg in config[DOMAIN].items():
|
|
if object_id != slugify(object_id):
|
|
_LOGGER.warning("Found invalid key for boolean input: %s. "
|
|
"Use %s instead", object_id, slugify(object_id))
|
|
continue
|
|
if not cfg:
|
|
_LOGGER.warning("No configuration specified for %s", object_id)
|
|
continue
|
|
|
|
name = cfg.get(CONF_NAME)
|
|
options = cfg.get(CONF_OPTIONS)
|
|
|
|
if not isinstance(options, list) or len(options) == 0:
|
|
_LOGGER.warning('Key %s should be a list of options', CONF_OPTIONS)
|
|
continue
|
|
|
|
options = [str(val) for val in options]
|
|
|
|
state = cfg.get(CONF_INITIAL)
|
|
|
|
if state not in options:
|
|
state = options[0]
|
|
|
|
icon = cfg.get(CONF_ICON)
|
|
|
|
entities.append(InputSelect(object_id, name, state, options, icon))
|
|
|
|
if not entities:
|
|
return False
|
|
|
|
def select_option_service(call):
|
|
""" Handle a calls to the input select services. """
|
|
target_inputs = component.extract_from_service(call)
|
|
|
|
for input_select in target_inputs:
|
|
input_select.select_option(call.data.get(ATTR_OPTION))
|
|
|
|
hass.services.register(DOMAIN, SERVICE_SELECT_OPTION,
|
|
select_option_service)
|
|
|
|
component.add_entities(entities)
|
|
|
|
return True
|
|
|
|
|
|
class InputSelect(Entity):
|
|
""" Represent a select input. """
|
|
|
|
# pylint: disable=too-many-arguments
|
|
def __init__(self, object_id, name, state, options, icon):
|
|
""" Initialize a select input. """
|
|
self.entity_id = ENTITY_ID_FORMAT.format(object_id)
|
|
self._name = name
|
|
self._current_option = state
|
|
self._options = options
|
|
self._icon = icon
|
|
|
|
@property
|
|
def should_poll(self):
|
|
""" If entity should be polled. """
|
|
return False
|
|
|
|
@property
|
|
def name(self):
|
|
""" Name of the select input. """
|
|
return self._name
|
|
|
|
@property
|
|
def icon(self):
|
|
""" Icon to be used for this entity. """
|
|
return self._icon
|
|
|
|
@property
|
|
def state(self):
|
|
""" State of the component. """
|
|
return self._current_option
|
|
|
|
@property
|
|
def state_attributes(self):
|
|
""" State attributes. """
|
|
return {
|
|
ATTR_OPTIONS: self._options,
|
|
}
|
|
|
|
def select_option(self, option):
|
|
""" Select new option. """
|
|
if option not in self._options:
|
|
_LOGGER.warning('Invalid option: %s (possible options: %s)',
|
|
option, ', '.join(self._options))
|
|
return
|
|
self._current_option = option
|
|
self.update_ha_state()
|