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

Rename input_slider to input_number and add numeric text box option (#9494)

Browse source 
* * Rename input_slider to input_number
* Update input_number to optionally display slider, input box, or both

* input_number support either input box or slider mode, but not both

* input_number : change service from select_value to set_value

* input_number : add test for mode setting to tests
This commit is contained in:
BioSehnsucht 2017-10-03 14:34:13 -05:00 • committed by Pascal Vizeli
parent 29e973d060
commit 3c0d02f057
6 changed files with 101 additions and 58 deletions
Download patch file Download diff file Expand all files Collapse all files

6
homeassistant/components/demo.py
View file

@ -87,8 +87,8 @@ def async_setup(hass, config):
# Set up input boolean # Set up input boolean
tasks.append(bootstrap.async_setup_component( tasks.append(bootstrap.async_setup_component(
hass, 'input_slider', hass, 'input_number',
{'input_slider': { {'input_number': {
'noise_allowance': {'icon': 'mdi:bell-ring', 'noise_allowance': {'icon': 'mdi:bell-ring',
'min': 0, 'min': 0,
'max': 10, 'max': 10,
@ -163,7 +163,7 @@ def async_setup(hass, config):
'scene.romantic_lights'])) 'scene.romantic_lights']))
tasks2.append(group.Group.async_create_group(hass, 'Bedroom', [ tasks2.append(group.Group.async_create_group(hass, 'Bedroom', [
lights[0], switches[1], media_players[0], lights[0], switches[1], media_players[0],
'input_slider.noise_allowance'])) 'input_number.noise_allowance']))
tasks2.append(group.Group.async_create_group(hass, 'Kitchen', [ tasks2.append(group.Group.async_create_group(hass, 'Kitchen', [
lights[2], 'cover.kitchen_window', 'lock.kitchen_door'])) lights[2], 'cover.kitchen_window', 'lock.kitchen_door']))
tasks2.append(group.Group.async_create_group(hass, 'Doors', [ tasks2.append(group.Group.async_create_group(hass, 'Doors', [

63
homeassistant/components/input_slider.py → homeassistant/components/input_number.py
View file

@ -1,8 +1,8 @@
""" """
Component to offer a way to select a value from a slider. Component to offer a way to set a numeric value from a slider or text box.
For more details about this component, please refer to the documentation For more details about this component, please refer to the documentation
at https://home-assistant.io/components/input_slider/ at https://home-assistant.io/components/input_number/
""" """
import asyncio import asyncio
import logging import logging
@ -19,29 +19,34 @@ from homeassistant.helpers.restore_state import async_get_last_state
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
DOMAIN = 'input_slider' DOMAIN = 'input_number'
ENTITY_ID_FORMAT = DOMAIN + '.{}' ENTITY_ID_FORMAT = DOMAIN + '.{}'
CONF_INITIAL = 'initial' CONF_INITIAL = 'initial'
CONF_MIN = 'min' CONF_MIN = 'min'
CONF_MAX = 'max' CONF_MAX = 'max'
CONF_MODE = 'mode'
CONF_STEP = 'step' CONF_STEP = 'step'
MODE_SLIDER = 'slider'
MODE_BOX = 'box'
ATTR_VALUE = 'value' ATTR_VALUE = 'value'
ATTR_MIN = 'min' ATTR_MIN = 'min'
ATTR_MAX = 'max' ATTR_MAX = 'max'
ATTR_STEP = 'step' ATTR_STEP = 'step'
ATTR_MODE = 'mode'
SERVICE_SELECT_VALUE = 'select_value' SERVICE_SET_VALUE = 'set_value'
SERVICE_SELECT_VALUE_SCHEMA = vol.Schema({ SERVICE_SET_VALUE_SCHEMA = vol.Schema({
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids, vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_VALUE): vol.Coerce(float), vol.Required(ATTR_VALUE): vol.Coerce(float),
}) })
def _cv_input_slider(cfg): def _cv_input_number(cfg):
"""Configure validation helper for input slider (voluptuous).""" """Configure validation helper for input number (voluptuous)."""
minimum = cfg.get(CONF_MIN) minimum = cfg.get(CONF_MIN)
maximum = cfg.get(CONF_MAX) maximum = cfg.get(CONF_MAX)
if minimum >= maximum: if minimum >= maximum:
@ -64,16 +69,18 @@ CONFIG_SCHEMA = vol.Schema({
vol.Optional(CONF_STEP, default=1): vol.Optional(CONF_STEP, default=1):
vol.All(vol.Coerce(float), vol.Range(min=1e-3)), vol.All(vol.Coerce(float), vol.Range(min=1e-3)),
vol.Optional(CONF_ICON): cv.icon, vol.Optional(CONF_ICON): cv.icon,
vol.Optional(ATTR_UNIT_OF_MEASUREMENT): cv.string vol.Optional(ATTR_UNIT_OF_MEASUREMENT): cv.string,
}, _cv_input_slider) vol.Optional(CONF_MODE, default=MODE_SLIDER):
vol.In([MODE_BOX, MODE_SLIDER]),
}, _cv_input_number)
}) })
}, required=True, extra=vol.ALLOW_EXTRA) }, required=True, extra=vol.ALLOW_EXTRA)
@bind_hass @bind_hass
def select_value(hass, entity_id, value): def set_value(hass, entity_id, value):
"""Set input_slider to value.""" """Set input_number to value."""
hass.services.call(DOMAIN, SERVICE_SELECT_VALUE, { hass.services.call(DOMAIN, SERVICE_SET_VALUE, {
ATTR_ENTITY_ID: entity_id, ATTR_ENTITY_ID: entity_id,
ATTR_VALUE: value, ATTR_VALUE: value,
}) })
@ -94,37 +101,39 @@ def async_setup(hass, config):
step = cfg.get(CONF_STEP) step = cfg.get(CONF_STEP)
icon = cfg.get(CONF_ICON) icon = cfg.get(CONF_ICON)
unit = cfg.get(ATTR_UNIT_OF_MEASUREMENT) unit = cfg.get(ATTR_UNIT_OF_MEASUREMENT)
mode = cfg.get(CONF_MODE)
entities.append(InputSlider( entities.append(InputNumber(
object_id, name, initial, minimum, maximum, step, icon, unit)) object_id, name, initial, minimum, maximum, step, icon, unit,
mode))
if not entities: if not entities:
return False return False
@asyncio.coroutine @asyncio.coroutine
def async_select_value_service(call): def async_set_value_service(call):
"""Handle a calls to the input slider services.""" """Handle a calls to the input slider services."""
target_inputs = component.async_extract_from_service(call) target_inputs = component.async_extract_from_service(call)
tasks = [input_slider.async_select_value(call.data[ATTR_VALUE]) tasks = [input_number.async_set_value(call.data[ATTR_VALUE])
for input_slider in target_inputs] for input_number in target_inputs]
if tasks: if tasks:
yield from asyncio.wait(tasks, loop=hass.loop) yield from asyncio.wait(tasks, loop=hass.loop)
hass.services.async_register( hass.services.async_register(
DOMAIN, SERVICE_SELECT_VALUE, async_select_value_service, DOMAIN, SERVICE_SET_VALUE, async_set_value_service,
schema=SERVICE_SELECT_VALUE_SCHEMA) schema=SERVICE_SET_VALUE_SCHEMA)
yield from component.async_add_entities(entities) yield from component.async_add_entities(entities)
return True return True
class InputSlider(Entity): class InputNumber(Entity):
"""Represent an slider.""" """Represent an slider."""
def __init__(self, object_id, name, initial, minimum, maximum, step, icon, def __init__(self, object_id, name, initial, minimum, maximum, step, icon,
unit): unit, mode):
"""Initialize a select input.""" """Initialize an input number."""
self.entity_id = ENTITY_ID_FORMAT.format(object_id) self.entity_id = ENTITY_ID_FORMAT.format(object_id)
self._name = name self._name = name
self._current_value = initial self._current_value = initial
@ -133,6 +142,7 @@ class InputSlider(Entity):
self._step = step self._step = step
self._icon = icon self._icon = icon
self._unit = unit self._unit = unit
self._mode = mode
@property @property
def should_poll(self): def should_poll(self):
@ -141,7 +151,7 @@ class InputSlider(Entity):
@property @property
def name(self): def name(self):
"""Return the name of the select input slider.""" """Return the name of the input slider."""
return self._name return self._name
@property @property
@ -165,7 +175,8 @@ class InputSlider(Entity):
return { return {
ATTR_MIN: self._minimum, ATTR_MIN: self._minimum,
ATTR_MAX: self._maximum, ATTR_MAX: self._maximum,
ATTR_STEP: self._step ATTR_STEP: self._step,
ATTR_MODE: self._mode,
} }
@asyncio.coroutine @asyncio.coroutine
@ -184,8 +195,8 @@ class InputSlider(Entity):
self._current_value = self._minimum self._current_value = self._minimum
@asyncio.coroutine @asyncio.coroutine
def async_select_value(self, value): def async_set_value(self, value):
"""Select new value.""" """Set new value."""
num_value = float(value) num_value = float(value)
if num_value < self._minimum or num_value > self._maximum: if num_value < self._minimum or num_value > self._maximum:
_LOGGER.warning("Invalid value: %s (range %s - %s)", _LOGGER.warning("Invalid value: %s (range %s - %s)",

12
tests/components/cover/test_template.py
View file

@ -409,8 +409,8 @@ class TestTemplateCover(unittest.TestCase):
def test_set_position(self): def test_set_position(self):
"""Test the set_position command.""" """Test the set_position command."""
with assert_setup_component(1, 'cover'): with assert_setup_component(1, 'cover'):
assert setup.setup_component(self.hass, 'input_slider', { assert setup.setup_component(self.hass, 'input_number', {
'input_slider': { 'input_number': {
'test': { 'test': {
'min': '0', 'min': '0',
'max': '100', 'max': '100',
@ -424,10 +424,10 @@ class TestTemplateCover(unittest.TestCase):
'covers': { 'covers': {
'test_template_cover': { 'test_template_cover': {
'position_template': 'position_template':
"{{ states.input_slider.test.state | int }}", "{{ states.input_number.test.state | int }}",
'set_cover_position': { 'set_cover_position': {
'service': 'input_slider.select_value', 'service': 'input_number.set_value',
'entity_id': 'input_slider.test', 'entity_id': 'input_number.test',
'data_template': { 'data_template': {
'value': '{{ position }}' 'value': '{{ position }}'
}, },
@ -440,7 +440,7 @@ class TestTemplateCover(unittest.TestCase):
self.hass.start() self.hass.start()
self.hass.block_till_done() self.hass.block_till_done()
state = self.hass.states.set('input_slider.test', 42) state = self.hass.states.set('input_number.test', 42)
self.hass.block_till_done() self.hass.block_till_done()
state = self.hass.states.get('cover.test_template_cover') state = self.hass.states.get('cover.test_template_cover')
assert state.state == STATE_OPEN assert state.state == STATE_OPEN

4
tests/components/media_player/test_universal.py
View file

@ -5,7 +5,7 @@ import unittest
from homeassistant.const import ( from homeassistant.const import (
STATE_OFF, STATE_ON, STATE_UNKNOWN, STATE_PLAYING, STATE_PAUSED) STATE_OFF, STATE_ON, STATE_UNKNOWN, STATE_PLAYING, STATE_PAUSED)
import homeassistant.components.switch as switch import homeassistant.components.switch as switch
import homeassistant.components.input_slider as input_slider import homeassistant.components.input_number as input_number
import homeassistant.components.input_select as input_select import homeassistant.components.input_select as input_select
import homeassistant.components.media_player as media_player import homeassistant.components.media_player as media_player
import homeassistant.components.media_player.universal as universal import homeassistant.components.media_player.universal as universal
@ -166,7 +166,7 @@ class TestMediaPlayer(unittest.TestCase):
self.mock_state_switch_id = switch.ENTITY_ID_FORMAT.format('state') self.mock_state_switch_id = switch.ENTITY_ID_FORMAT.format('state')
self.hass.states.set(self.mock_state_switch_id, STATE_OFF) self.hass.states.set(self.mock_state_switch_id, STATE_OFF)
self.mock_volume_id = input_slider.ENTITY_ID_FORMAT.format( self.mock_volume_id = input_number.ENTITY_ID_FORMAT.format(
'volume_level') 'volume_level')
self.hass.states.set(self.mock_volume_id, 0) self.hass.states.set(self.mock_volume_id, 0)

70
tests/components/test_input_slider.py → tests/components/test_input_number.py
View file

@ -1,17 +1,17 @@
"""The tests for the Input slider component.""" """The tests for the Input number component."""
# pylint: disable=protected-access # pylint: disable=protected-access
import asyncio import asyncio
import unittest import unittest
from homeassistant.core import CoreState, State from homeassistant.core import CoreState, State
from homeassistant.setup import setup_component, async_setup_component from homeassistant.setup import setup_component, async_setup_component
from homeassistant.components.input_slider import (DOMAIN, select_value) from homeassistant.components.input_number import (DOMAIN, set_value)
from tests.common import get_test_home_assistant, mock_restore_cache from tests.common import get_test_home_assistant, mock_restore_cache
class TestInputSlider(unittest.TestCase): class TestInputNumber(unittest.TestCase):
"""Test the input slider component.""" """Test the input number component."""
# pylint: disable=invalid-name # pylint: disable=invalid-name
def setUp(self): def setUp(self):
@ -38,8 +38,8 @@ class TestInputSlider(unittest.TestCase):
self.assertFalse( self.assertFalse(
setup_component(self.hass, DOMAIN, {DOMAIN: cfg})) setup_component(self.hass, DOMAIN, {DOMAIN: cfg}))
def test_select_value(self): def test_set_value(self):
"""Test select_value method.""" """Test set_value method."""
self.assertTrue(setup_component(self.hass, DOMAIN, {DOMAIN: { self.assertTrue(setup_component(self.hass, DOMAIN, {DOMAIN: {
'test_1': { 'test_1': {
'initial': 50, 'initial': 50,
@ -47,36 +47,68 @@ class TestInputSlider(unittest.TestCase):
'max': 100, 'max': 100,
}, },
}})) }}))
entity_id = 'input_slider.test_1' entity_id = 'input_number.test_1'
state = self.hass.states.get(entity_id) state = self.hass.states.get(entity_id)
self.assertEqual(50, float(state.state)) self.assertEqual(50, float(state.state))
select_value(self.hass, entity_id, '30.4') set_value(self.hass, entity_id, '30.4')
self.hass.block_till_done() self.hass.block_till_done()
state = self.hass.states.get(entity_id) state = self.hass.states.get(entity_id)
self.assertEqual(30.4, float(state.state)) self.assertEqual(30.4, float(state.state))
select_value(self.hass, entity_id, '70') set_value(self.hass, entity_id, '70')
self.hass.block_till_done() self.hass.block_till_done()
state = self.hass.states.get(entity_id) state = self.hass.states.get(entity_id)
self.assertEqual(70, float(state.state)) self.assertEqual(70, float(state.state))
select_value(self.hass, entity_id, '110') set_value(self.hass, entity_id, '110')
self.hass.block_till_done() self.hass.block_till_done()
state = self.hass.states.get(entity_id) state = self.hass.states.get(entity_id)
self.assertEqual(70, float(state.state)) self.assertEqual(70, float(state.state))
def test_mode(self):
"""Test mode settings."""
self.assertTrue(
setup_component(self.hass, DOMAIN, {DOMAIN: {
'test_default_slider': {
'min': 0,
'max': 100,
},
'test_explicit_box': {
'min': 0,
'max': 100,
'mode': 'box',
},
'test_explicit_slider': {
'min': 0,
'max': 100,
'mode': 'slider',
},
}}))
state = self.hass.states.get('input_number.test_default_slider')
assert state
self.assertEqual('slider', state.attributes['mode'])
state = self.hass.states.get('input_number.test_explicit_box')
assert state
self.assertEqual('box', state.attributes['mode'])
state = self.hass.states.get('input_number.test_explicit_slider')
assert state
self.assertEqual('slider', state.attributes['mode'])
@asyncio.coroutine @asyncio.coroutine
def test_restore_state(hass): def test_restore_state(hass):
"""Ensure states are restored on startup.""" """Ensure states are restored on startup."""
mock_restore_cache(hass, ( mock_restore_cache(hass, (
State('input_slider.b1', '70'), State('input_number.b1', '70'),
State('input_slider.b2', '200'), State('input_number.b2', '200'),
)) ))
hass.state = CoreState.starting hass.state = CoreState.starting
@ -93,11 +125,11 @@ def test_restore_state(hass):
}, },
}}) }})
state = hass.states.get('input_slider.b1') state = hass.states.get('input_number.b1')
assert state assert state
assert float(state.state) == 70 assert float(state.state) == 70
state = hass.states.get('input_slider.b2') state = hass.states.get('input_number.b2')
assert state assert state
assert float(state.state) == 10 assert float(state.state) == 10
@ -106,8 +138,8 @@ def test_restore_state(hass):
def test_initial_state_overrules_restore_state(hass): def test_initial_state_overrules_restore_state(hass):
"""Ensure states are restored on startup.""" """Ensure states are restored on startup."""
mock_restore_cache(hass, ( mock_restore_cache(hass, (
State('input_slider.b1', '70'), State('input_number.b1', '70'),
State('input_slider.b2', '200'), State('input_number.b2', '200'),
)) ))
hass.state = CoreState.starting hass.state = CoreState.starting
@ -126,11 +158,11 @@ def test_initial_state_overrules_restore_state(hass):
}, },
}}) }})
state = hass.states.get('input_slider.b1') state = hass.states.get('input_number.b1')
assert state assert state
assert float(state.state) == 50 assert float(state.state) == 50
state = hass.states.get('input_slider.b2') state = hass.states.get('input_number.b2')
assert state assert state
assert float(state.state) == 60 assert float(state.state) == 60
@ -148,6 +180,6 @@ def test_no_initial_state_and_no_restore_state(hass):
}, },
}}) }})
state = hass.states.get('input_slider.b1') state = hass.states.get('input_number.b1')
assert state assert state
assert float(state.state) == 0 assert float(state.state) == 0

4
tests/helpers/test_template.py
View file

@ -745,11 +745,11 @@ is_state_attr('device_tracker.phone_2', 'battery', 40)
self.assertListEqual( self.assertListEqual(
sorted([ sorted([
'sensor.luftfeuchtigkeit_mean', 'sensor.luftfeuchtigkeit_mean',
'input_slider.luftfeuchtigkeit', 'input_number.luftfeuchtigkeit',
]), ]),
sorted(template.extract_entities( sorted(template.extract_entities(
"{% if (states('sensor.luftfeuchtigkeit_mean') | int)" "{% if (states('sensor.luftfeuchtigkeit_mean') | int)"
" > (states('input_slider.luftfeuchtigkeit') | int +1.5)" " > (states('input_number.luftfeuchtigkeit') | int +1.5)"
" %}true{% endif %}" " %}true{% endif %}"
))) )))