Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rename component to motor and services to open/close/stop

pull/655/head
sfam 2015-11-25 18:13:39 +00:00
parent 351430c1b3
commit 08ba71a359
6 changed files with 184 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
homeassistant/components/motor/__init__.py Normal file
View File

@ -0,0 +1,130 @@
"""
homeassistant.components.motor
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Motor component.
"""
import os
import logging
from homeassistant.config import load_yaml_config_file
from homeassistant.helpers.entity_component import EntityComponent
from homeassistant.helpers.entity import Entity
from homeassistant.components import group
from homeassistant.const import (
SERVICE_OPEN, SERVICE_CLOSE, SERVICE_STOP,
STATE_OPEN, STATE_CLOSED, STATE_UNKNOWN, ATTR_ENTITY_ID)
DOMAIN = 'motor'
DEPENDENCIES = []
SCAN_INTERVAL = 15
GROUP_NAME_ALL_MOTORS = 'all motors'
ENTITY_ID_ALL_MOTORS = group.ENTITY_ID_FORMAT.format('all_motors')
ENTITY_ID_FORMAT = DOMAIN + '.{}'
# Maps discovered services to their platforms
DISCOVERY_PLATFORMS = {}
_LOGGER = logging.getLogger(__name__)
def is_open(hass, entity_id=None):
""" Returns if the motor is open based on the statemachine. """
entity_id = entity_id or ENTITY_ID_ALL_MOTORS
return hass.states.is_state(entity_id, STATE_OPEN)
def call_open(hass, entity_id=None):
""" Open all or specified motor. """
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.services.call(DOMAIN, SERVICE_OPEN, data)
def call_close(hass, entity_id=None):
""" Close all or specified motor. """
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.services.call(DOMAIN, SERVICE_CLOSE, data)
def call_stop(hass, entity_id=None):
""" Stops all or specified motor. """
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.services.call(DOMAIN, SERVICE_STOP, data)
def setup(hass, config):
""" Track states and offer events for motors. """
component = EntityComponent(
_LOGGER, DOMAIN, hass, SCAN_INTERVAL, DISCOVERY_PLATFORMS,
GROUP_NAME_ALL_MOTORS)
component.setup(config)
def handle_motor_service(service):
""" Handles calls to the motor services. """
target_motors = component.extract_from_service(service)
for motor in target_motors:
if service.service == SERVICE_OPEN:
motor.open()
elif service.service == SERVICE_CLOSE:
motor.close()
elif service.service == SERVICE_STOP:
motor.stop()
if motor.should_poll:
motor.update_ha_state(True)
descriptions = load_yaml_config_file(
os.path.join(os.path.dirname(__file__), 'services.yaml'))
hass.services.register(DOMAIN, SERVICE_OPEN,
handle_motor_service,
descriptions.get(SERVICE_OPEN))
hass.services.register(DOMAIN, SERVICE_CLOSE,
handle_motor_service,
descriptions.get(SERVICE_CLOSE))
hass.services.register(DOMAIN, SERVICE_STOP,
handle_motor_service,
descriptions.get(SERVICE_STOP))
return True
class MotorDevice(Entity):
""" Represents a motor within Home Assistant. """
# pylint: disable=no-self-use
@property
def current_position(self):
""" Return current position of motor.
None is unknown, 0 is closed, 100 is fully open. """
raise NotImplementedError()
@property
def state(self):
current = self.current_position
if current is None:
return STATE_UNKNOWN
return STATE_CLOSED if current == 0 else STATE_OPEN
@property
def state_attributes(self):
""" Returns optional state attributes. """
return None
def open(self, **kwargs):
""" Open the device. """
raise NotImplementedError()
def close(self, **kwargs):
""" Close the device. """
raise NotImplementedError()
def stop(self, **kwargs):
""" Stop the device. """
raise NotImplementedError()

52
homeassistant/components/rollershutter/mqtt.py → homeassistant/components/motor/mqtt.py
View File

@ -1,21 +1,21 @@
"""
homeassistant.components.rollershutter.mqtt
homeassistant.components.motor.mqtt
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Allows to configure a MQTT rollershutter.
Allows to configure a MQTT motor.
For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/rollershutter.mqtt/
https://home-assistant.io/components/motor.mqtt/
"""
import logging
import homeassistant.components.mqtt as mqtt
from homeassistant.components.rollershutter import RollershutterDevice
from homeassistant.components.motor import MotorDevice
_LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['mqtt']
DEFAULT_NAME = "MQTT Shutter"
DEFAULT_NAME = "MQTT Motor"
DEFAULT_QOS = 0
DEFAULT_PAYLOAD_UP = "UP"
DEFAULT_PAYLOAD_DOWN = "DOWN"
DEFAULT_PAYLOAD_OPEN = "OPEN"
DEFAULT_PAYLOAD_CLOSE = "CLOSE"
DEFAULT_PAYLOAD_STOP = "STOP"
ATTR_CURRENT_POSITION = 'current_position'
@ -23,37 +23,37 @@ ATTR_CURRENT_POSITION = 'current_position'
# pylint: disable=unused-argument
def setup_platform(hass, config, add_devices_callback, discovery_info=None):
""" Add MQTT Roller Shutter """
""" Add MQTT Motor """
if config.get('command_topic') is None:
_LOGGER.error("Missing required variable: command_topic")
return False
add_devices_callback([MqttRollershutter(
add_devices_callback([MqttMotor(
hass,
config.get('name', DEFAULT_NAME),
config.get('state_topic'),
config.get('command_topic'),
config.get('qos', DEFAULT_QOS),
config.get('payload_up', DEFAULT_PAYLOAD_UP),
config.get('payload_down', DEFAULT_PAYLOAD_DOWN),
config.get('payload_open', DEFAULT_PAYLOAD_OPEN),
config.get('payload_close', DEFAULT_PAYLOAD_CLOSE),
config.get('payload_stop', DEFAULT_PAYLOAD_STOP),
config.get('state_format'))])
# pylint: disable=too-many-arguments, too-many-instance-attributes
class MqttRollershutter(RollershutterDevice):
""" Represents a rollershutter that can be togggled using MQTT """
class MqttMotor(MotorDevice):
""" Represents a motor that can be controlled using MQTT """
def __init__(self, hass, name, state_topic, command_topic, qos,
payload_up, payload_down, payload_stop, state_format):
payload_open, payload_close, payload_stop, state_format):
self._state = None
self._hass = hass
self._name = name
self._state_topic = state_topic
self._command_topic = command_topic
self._qos = qos
self._payload_up = payload_up
self._payload_down = payload_down
self._payload_open = payload_open
self._payload_close = payload_close
self._payload_stop = payload_stop
self._parse = mqtt.FmtParser(state_format)
@ -79,12 +79,12 @@ class MqttRollershutter(RollershutterDevice):
@property
def name(self):
""" The name of the rollershutter """
""" The name of the motor """
return self._name
@property
def current_position(self):
""" Return current position of rollershutter.
""" Return current position of motor.
None is unknown, 0 is closed, 100 is fully open. """
return self._state
@ -93,18 +93,18 @@ class MqttRollershutter(RollershutterDevice):
""" True if device is open. """
return self._state > 0
def move_up(self, **kwargs):
""" Moves the device UP. """
mqtt.publish(self.hass, self._command_topic, self._payload_up,
def open(self, **kwargs):
""" Close the device. """
mqtt.publish(self.hass, self._command_topic, self._payload_open,
self._qos)
def move_down(self, **kwargs):
""" Moves the device DOWN. """
mqtt.publish(self.hass, self._command_topic, self._payload_down,
def close(self, **kwargs):
""" Open the device. """
mqtt.publish(self.hass, self._command_topic, self._payload_close,
self._qos)
def move_stop(self, **kwargs):
""" Moves the device to STOP. """
def stop(self, **kwargs):
""" Stop the device. """
mqtt.publish(self.hass, self._command_topic, self._payload_stop,
self._qos)

0
homeassistant/components/rollershutter/services.yaml → homeassistant/components/motor/services.yaml
View File

131
homeassistant/components/rollershutter/__init__.py
View File

@ -1,131 +0,0 @@
"""
homeassistant.components.rollershutter
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Rollershutter component.
"""
import os
import logging
from homeassistant.config import load_yaml_config_file
from homeassistant.helpers.entity_component import EntityComponent
from homeassistant.helpers.entity import Entity
from homeassistant.components import group
from homeassistant.const import (
SERVICE_MOVE_UP, SERVICE_MOVE_DOWN, SERVICE_MOVE_STOP,
STATE_OPEN, STATE_CLOSED, STATE_UNKNOWN, ATTR_ENTITY_ID)
DOMAIN = 'rollershutter'
DEPENDENCIES = []
SCAN_INTERVAL = 15
GROUP_NAME_ALL_ROLLERSHUTTERS = 'all rollershutters'
ENTITY_ID_ALL_ROLLERSHUTTERS = group.ENTITY_ID_FORMAT.format(
'all_rollershutters')
ENTITY_ID_FORMAT = DOMAIN + '.{}'
# Maps discovered services to their platforms
DISCOVERY_PLATFORMS = {}
_LOGGER = logging.getLogger(__name__)
def is_open(hass, entity_id=None):
""" Returns if the rollershutter is open based on the statemachine. """
entity_id = entity_id or ENTITY_ID_ALL_ROLLERSHUTTERS
return hass.states.is_state(entity_id, STATE_OPEN)
def move_up(hass, entity_id=None):
""" Moves all or specified rollershutter up. """
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.services.call(DOMAIN, SERVICE_MOVE_UP, data)
def move_down(hass, entity_id=None):
""" Moves all or specified rollershutter down. """
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.services.call(DOMAIN, SERVICE_MOVE_DOWN, data)
def move_stop(hass, entity_id=None):
""" Stops all or specified rollershutter. """
data = {ATTR_ENTITY_ID: entity_id} if entity_id else None
hass.services.call(DOMAIN, SERVICE_MOVE_STOP, data)
def setup(hass, config):
""" Track states and offer events for rollershutters. """
component = EntityComponent(
_LOGGER, DOMAIN, hass, SCAN_INTERVAL, DISCOVERY_PLATFORMS,
GROUP_NAME_ALL_ROLLERSHUTTERS)
component.setup(config)
def handle_rollershutter_service(service):
""" Handles calls to the rollershutter services. """
target_rollershutters = component.extract_from_service(service)
for rollershutter in target_rollershutters:
if service.service == SERVICE_MOVE_UP:
rollershutter.move_up()
elif service.service == SERVICE_MOVE_DOWN:
rollershutter.move_down()
elif service.service == SERVICE_MOVE_STOP:
rollershutter.move_stop()
if rollershutter.should_poll:
rollershutter.update_ha_state(True)
descriptions = load_yaml_config_file(
os.path.join(os.path.dirname(__file__), 'services.yaml'))
hass.services.register(DOMAIN, SERVICE_MOVE_UP,
handle_rollershutter_service,
descriptions.get(SERVICE_MOVE_UP))
hass.services.register(DOMAIN, SERVICE_MOVE_DOWN,
handle_rollershutter_service,
descriptions.get(SERVICE_MOVE_DOWN))
hass.services.register(DOMAIN, SERVICE_MOVE_STOP,
handle_rollershutter_service,
descriptions.get(SERVICE_MOVE_STOP))
return True
class RollershutterDevice(Entity):
""" Represents a rollershutter within Home Assistant. """
# pylint: disable=no-self-use
@property
def current_position(self):
""" Return current position of rollershutter.
None is unknown, 0 is closed, 100 is fully open. """
raise NotImplementedError()
@property
def state(self):
current = self.current_position
if current is None:
return STATE_UNKNOWN
return STATE_CLOSED if current == 0 else STATE_OPEN
@property
def state_attributes(self):
""" Returns optional state attributes. """
return None
def move_up(self, **kwargs):
""" Moves the device UP. """
raise NotImplementedError()
def move_down(self, **kwargs):
""" Moves the device DOWN. """
raise NotImplementedError()
def move_stop(self, **kwargs):
""" Moves the device to STOP. """
raise NotImplementedError()

0
tests/components/rollershutter/__init__.py → tests/components/motor/__init__.py
View File

56
tests/components/rollershutter/test_mqtt.py → tests/components/motor/test_mqtt.py
View File

@ -1,19 +1,19 @@
"""
tests.components.rollershutter.test_mqtt
tests.components.motor.test_mqtt
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Tests mqtt rollershutter.
Tests mqtt motor.
"""
import unittest
from homeassistant.const import STATE_OPEN, STATE_CLOSED, STATE_UNKNOWN
import homeassistant.core as ha
import homeassistant.components.rollershutter as rollershutter
import homeassistant.components.motor as motor
from tests.common import mock_mqtt_component, fire_mqtt_message
class TestRollershutterMQTT(unittest.TestCase):
""" Test the MQTT rollershutter. """
class TestMotorMQTT(unittest.TestCase):
""" Test the MQTT motor. """
def setUp(self): # pylint: disable=invalid-name
self.hass = ha.HomeAssistant()
@ -24,43 +24,43 @@ class TestRollershutterMQTT(unittest.TestCase):
self.hass.stop()
def test_controlling_state_via_topic(self):
self.assertTrue(rollershutter.setup(self.hass, {
'rollershutter': {
self.assertTrue(motor.setup(self.hass, {
'motor': {
'platform': 'mqtt',
'name': 'test',
'state_topic': 'state-topic',
'command_topic': 'command-topic',
'qos': 0,
'payload_up': 'UP',
'payload_down': 'DOWN',
'payload_open': 'OPEN',
'payload_close': 'CLOSE',
'payload_stop': 'STOP'
}
}))
state = self.hass.states.get('rollershutter.test')
state = self.hass.states.get('motor.test')
self.assertEqual(STATE_UNKNOWN, state.state)
fire_mqtt_message(self.hass, 'state-topic', '0')
self.hass.pool.block_till_done()
state = self.hass.states.get('rollershutter.test')
state = self.hass.states.get('motor.test')
self.assertEqual(STATE_CLOSED, state.state)
fire_mqtt_message(self.hass, 'state-topic', '50')
self.hass.pool.block_till_done()
state = self.hass.states.get('rollershutter.test')
state = self.hass.states.get('motor.test')
self.assertEqual(STATE_OPEN, state.state)
fire_mqtt_message(self.hass, 'state-topic', '100')
self.hass.pool.block_till_done()
state = self.hass.states.get('rollershutter.test')
state = self.hass.states.get('motor.test')
self.assertEqual(STATE_OPEN, state.state)
def test_sending_mqtt_commands(self):
self.assertTrue(rollershutter.setup(self.hass, {
'rollershutter': {
self.assertTrue(motor.setup(self.hass, {
'motor': {
'platform': 'mqtt',
'name': 'test',
'state_topic': 'state-topic',
@ -69,54 +69,54 @@ class TestRollershutterMQTT(unittest.TestCase):
}
}))
state = self.hass.states.get('rollershutter.test')
state = self.hass.states.get('motor.test')
self.assertEqual(STATE_UNKNOWN, state.state)
rollershutter.move_up(self.hass, 'rollershutter.test')
motor.call_open(self.hass, 'motor.test')
self.hass.pool.block_till_done()
self.assertEqual(('command-topic', 'UP', 2),
self.assertEqual(('command-topic', 'OPEN', 2),
self.mock_publish.mock_calls[-1][1])
state = self.hass.states.get('rollershutter.test')
state = self.hass.states.get('motor.test')
self.assertEqual(STATE_UNKNOWN, state.state)
def test_state_attributes_current_position(self):
self.assertTrue(rollershutter.setup(self.hass, {
'rollershutter': {
self.assertTrue(motor.setup(self.hass, {
'motor': {
'platform': 'mqtt',
'name': 'test',
'state_topic': 'state-topic',
'command_topic': 'command-topic',
'payload_up': 'UP',
'payload_down': 'DOWN',
'payload_open': 'OPEN',
'payload_close': 'CLOSE',
'payload_stop': 'STOP'
}
}))
state_attributes_dict = self.hass.states.get(
'rollershutter.test').attributes
'motor.test').attributes
self.assertFalse('current_position' in state_attributes_dict)
fire_mqtt_message(self.hass, 'state-topic', '0')
self.hass.pool.block_till_done()
current_position = self.hass.states.get(
'rollershutter.test').attributes['current_position']
'motor.test').attributes['current_position']
self.assertEqual(0, current_position)
fire_mqtt_message(self.hass, 'state-topic', '50')
self.hass.pool.block_till_done()
current_position = self.hass.states.get(
'rollershutter.test').attributes['current_position']
'motor.test').attributes['current_position']
self.assertEqual(50, current_position)
fire_mqtt_message(self.hass, 'state-topic', '101')
self.hass.pool.block_till_done()
current_position = self.hass.states.get(
'rollershutter.test').attributes['current_position']
'motor.test').attributes['current_position']
self.assertEqual(50, current_position)
fire_mqtt_message(self.hass, 'state-topic', 'non-numeric')
self.hass.pool.block_till_done()
current_position = self.hass.states.get(
'rollershutter.test').attributes['current_position']
'motor.test').attributes['current_position']
self.assertEqual(50, current_position)