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

homeassistant/components/motor/__init__.py

@@ -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()

homeassistant/components/motor/mqtt.py

@@ -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_OPEN = "OPEN"
-DEFAULT_PAYLOAD_DOWN = "DOWN"
+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_open', DEFAULT_PAYLOAD_OPEN),
-        config.get('payload_down', DEFAULT_PAYLOAD_DOWN),
+        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):
+class MqttMotor(MotorDevice):
-    """ Represents a rollershutter that can be togggled using MQTT """
+    """ 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_open = payload_open
-        self._payload_down = payload_down
+        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):
+    def open(self, **kwargs):
-        """ Moves the device UP. """
+        """ Close the device. """
-        mqtt.publish(self.hass, self._command_topic, self._payload_up,
+        mqtt.publish(self.hass, self._command_topic, self._payload_open,
                      self._qos)
 
-    def move_down(self, **kwargs):
+    def close(self, **kwargs):
-        """ Moves the device DOWN. """
+        """ Open the device. """
-        mqtt.publish(self.hass, self._command_topic, self._payload_down,
+        mqtt.publish(self.hass, self._command_topic, self._payload_close,
                      self._qos)
 
-    def move_stop(self, **kwargs):
+    def stop(self, **kwargs):
-        """ Moves the device to STOP. """
+        """ Stop the device. """
         mqtt.publish(self.hass, self._command_topic, self._payload_stop,
                      self._qos)
 

homeassistant/components/rollershutter/__init__.py

@@ -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()

tests/components/motor/test_mqtt.py

@@ -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):
+class TestMotorMQTT(unittest.TestCase):
-    """ Test the MQTT rollershutter. """
+    """ 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, {
+        self.assertTrue(motor.setup(self.hass, {
-            'rollershutter': {
+            'motor': {
                 'platform': 'mqtt',
                 'name': 'test',
                 'state_topic': 'state-topic',
                 'command_topic': 'command-topic',
                 'qos': 0,
-                'payload_up': 'UP',
+                'payload_open': 'OPEN',
-                'payload_down': 'DOWN',
+                '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, {
+        self.assertTrue(motor.setup(self.hass, {
-            'rollershutter': {
+            '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, {
+        self.assertTrue(motor.setup(self.hass, {
-            'rollershutter': {
+            'motor': {
                 'platform': 'mqtt',
                 'name': 'test',
                 'state_topic': 'state-topic',
                 'command_topic': 'command-topic',
-                'payload_up': 'UP',
+                'payload_open': 'OPEN',
-                'payload_down': 'DOWN',
+                '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)