Split out dovado to a component and sensor platform (#20339)

* Split out dovado to a component and sensor platform

* Lint

* Address code review comments (#20339)

* Switch to using a notify platform for dovado SMS (#20339)

* Optimizing imports

* Remove return on `setup_platform`.

* Clean up unneeded constants

.coveragerc

@@ -87,6 +87,8 @@ omit =
     homeassistant/components/doorbird.py
     homeassistant/components/*/doorbird.py
 
+    homeassistant/components/dovado/*
+
     homeassistant/components/dweet.py
     homeassistant/components/*/dweet.py
 
@@ -754,7 +756,6 @@ omit =
     homeassistant/components/sensor/dht.py
     homeassistant/components/sensor/discogs.py
     homeassistant/components/sensor/dnsip.py
-    homeassistant/components/sensor/dovado.py
     homeassistant/components/sensor/domain_expiry.py
     homeassistant/components/sensor/dte_energy_bridge.py
     homeassistant/components/sensor/dublin_bus_transport.py

homeassistant/components/dovado/__init__.py

+"""
+Support for Dovado router.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/dovado/
+"""
+import logging
+from datetime import timedelta
+
+import voluptuous as vol
+
+import homeassistant.helpers.config_validation as cv
+from homeassistant.const import (
+    CONF_USERNAME, CONF_PASSWORD, CONF_HOST, CONF_PORT,
+    DEVICE_DEFAULT_NAME)
+from homeassistant.util import Throttle
+
+_LOGGER = logging.getLogger(__name__)
+
+REQUIREMENTS = ['dovado==0.4.1']
+
+DOMAIN = 'dovado'
+
+CONFIG_SCHEMA = vol.Schema({
+    vol.Required(CONF_USERNAME): cv.string,
+    vol.Required(CONF_PASSWORD): cv.string,
+    vol.Optional(CONF_HOST): cv.string,
+    vol.Optional(CONF_PORT): cv.port,
+})
+
+MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=30)
+
+
+def setup(hass, config):
+    """Set up the Dovado component."""
+    import dovado
+
+    hass.data[DOMAIN] = DovadoData(
+        dovado.Dovado(
+            config[CONF_USERNAME],
+            config[CONF_PASSWORD],
+            config.get(CONF_HOST),
+            config.get(CONF_PORT)
+        )
+    )
+    return True
+
+
+class DovadoData:
+    """Maintains a connection to the router."""
+
+    def __init__(self, client):
+        """Set up a new Dovado connection."""
+        self._client = client
+        self.state = {}
+
+    @property
+    def name(self):
+        """Name of the router."""
+        return self.state.get("product name", DEVICE_DEFAULT_NAME)
+
+    @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    def update(self):
+        """Update device state."""
+        try:
+            self.state = self._client.state or {}
+            if not self.state:
+                return False
+            self.state.update(
+                connected=self.state.get("modem status") == "CONNECTED")
+            _LOGGER.debug("Received: %s", self.state)
+            return True
+        except OSError as error:
+            _LOGGER.warning("Could not contact the router: %s", error)
+
+    @property
+    def client(self):
+        """Dovado client instance."""
+        return self._client

homeassistant/components/dovado/notify.py

+"""
+Support for SMS notifications from the Dovado router.
+
+For more details about this platform, please refer to the documentation at
+https://home-assistant.io/components/notify.dovado/
+"""
+import logging
+
+from homeassistant.components.dovado import DOMAIN as DOVADO_DOMAIN
+from homeassistant.components.notify import BaseNotificationService, \
+    ATTR_TARGET
+
+_LOGGER = logging.getLogger(__name__)
+
+DEPENDENCIES = ['dovado']
+
+
+def get_service(hass, config, discovery_info=None):
+    """Get the Dovado Router SMS notification service."""
+    return DovadoSMSNotificationService(hass.data[DOVADO_DOMAIN].client)
+
+
+class DovadoSMSNotificationService(BaseNotificationService):
+    """Implement the notification service for the Dovado SMS component."""
+
+    def __init__(self, client):
+        """Initialize the service."""
+        self._client = client
+
+    def send_message(self, message, **kwargs):
+        """Send SMS to the specified target phone number."""
+        target = kwargs.get(ATTR_TARGET)
+
+        if not target:
+            _LOGGER.error("One target is required")
+            return
+
+        self._client.send_sms(target, message)

homeassistant/components/sensor/dovado.py → homeassistant/components/dovado/sensor.py

 """
-Support for Dovado router.
+Support for sensors from the Dovado router.
 
 For more details about this platform, please refer to the documentation at
 https://home-assistant.io/components/sensor.dovado/
@@ -10,18 +10,15 @@ from datetime import timedelta
 
 import voluptuous as vol
 
-from homeassistant.helpers.entity import Entity
-from homeassistant.util import Throttle
-from homeassistant.util import slugify
 import homeassistant.helpers.config_validation as cv
-from homeassistant.const import (
-    CONF_USERNAME, CONF_PASSWORD, CONF_HOST, CONF_PORT, CONF_SENSORS,
-    DEVICE_DEFAULT_NAME)
-from homeassistant.components.sensor import (DOMAIN, PLATFORM_SCHEMA)
+from homeassistant.components.dovado import DOMAIN as DOVADO_DOMAIN
+from homeassistant.components.sensor import PLATFORM_SCHEMA
+from homeassistant.const import CONF_SENSORS
+from homeassistant.helpers.entity import Entity
 
 _LOGGER = logging.getLogger(__name__)
 
-REQUIREMENTS = ['dovado==0.4.1']
+DEPENDENCIES = ['dovado']
 
 MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=30)
 
@@ -45,87 +42,34 @@ SENSORS = {
 }
 
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
-    vol.Required(CONF_USERNAME): cv.string,
-    vol.Required(CONF_PASSWORD): cv.string,
-    vol.Optional(CONF_HOST): cv.string,
-    vol.Optional(CONF_PORT): cv.port,
-    vol.Optional(CONF_SENSORS):
-    vol.All(cv.ensure_list, [vol.In(SENSORS)]),
+    vol.Required(CONF_SENSORS): vol.All(
+        cv.ensure_list, [vol.In(SENSORS)]
+    ),
 })
 
 
 def setup_platform(hass, config, add_entities, discovery_info=None):
-    """Set up the Dovado platform for sensors."""
-    return Dovado().setup(hass, config, add_entities)
-
-
-class Dovado:
-    """A connection to the router."""
-
-    def __init__(self):
-        """Initialize."""
-        self.state = {}
-        self._dovado = None
-
-    def setup(self, hass, config, add_entities):
-        """Set up the connection."""
-        import dovado
-        self._dovado = dovado.Dovado(
-            config.get(CONF_USERNAME), config.get(CONF_PASSWORD),
-            config.get(CONF_HOST), config.get(CONF_PORT))
-
-        if not self.update():
-            return False
+    """Set up the Dovado sensor platform."""
+    dovado = hass.data[DOVADO_DOMAIN]
 
-        def send_sms(service):
-            """Send SMS through the router."""
-            number = service.data.get('number')
-            message = service.data.get('message')
-            _LOGGER.debug("message for %s: %s", number, message)
-            self._dovado.send_sms(number, message)
+    entities = []
+    for sensor in config[CONF_SENSORS]:
+        entities.append(DovadoSensor(dovado, sensor))
 
-        if self.state.get('sms') == 'enabled':
-            service_name = slugify("{} {}".format(self.name, 'send_sms'))
-            hass.services.register(DOMAIN, service_name, send_sms)
-
-        for sensor in SENSORS:
-            if sensor in config.get(CONF_SENSORS, [sensor]):
-                add_entities([DovadoSensor(self, sensor)])
-
-        return True
-
-    @property
-    def name(self):
-        """Name of the router."""
-        return self.state.get("product name", DEVICE_DEFAULT_NAME)
-
-    @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    def update(self):
-        """Update device state."""
-        _LOGGER.info("Updating")
-        try:
-            self.state = self._dovado.state or {}
-            if not self.state:
-                return False
-            self.state.update(
-                connected=self.state.get("modem status") == "CONNECTED")
-            _LOGGER.debug("Received: %s", self.state)
-            return True
-        except OSError as error:
-            _LOGGER.warning("Could not contact the router: %s", error)
+    add_entities(entities)
 
 
 class DovadoSensor(Entity):
     """Representation of a Dovado sensor."""
 
-    def __init__(self, dovado, sensor):
+    def __init__(self, data, sensor):
         """Initialize the sensor."""
-        self._dovado = dovado
+        self._data = data
         self._sensor = sensor
         self._state = self._compute_state()
 
     def _compute_state(self):
-        state = self._dovado.state.get(SENSORS[self._sensor][0])
+        state = self._data.state.get(SENSORS[self._sensor][0])
         if self._sensor == SENSOR_NETWORK:
             match = re.search(r"\((.+)\)", state)
             return match.group(1) if match else None
@@ -133,7 +77,7 @@ class DovadoSensor(Entity):
             try:
                 return int(state.split()[0])
             except ValueError:
-                return 0
+                return None
         if self._sensor == SENSOR_SMS_UNREAD:
             return int(state)
         if self._sensor in [SENSOR_UPLOAD, SENSOR_DOWNLOAD]:
@@ -142,13 +86,13 @@ class DovadoSensor(Entity):
 
     def update(self):
         """Update sensor values."""
-        self._dovado.update()
+        self._data.update()
         self._state = self._compute_state()
 
     @property
     def name(self):
         """Return the name of the sensor."""
-        return "{} {}".format(self._dovado.name, SENSORS[self._sensor][1])
+        return "{} {}".format(self._data.name, SENSORS[self._sensor][1])
 
     @property
     def state(self):
@@ -168,5 +112,5 @@ class DovadoSensor(Entity):
     @property
     def device_state_attributes(self):
         """Return the state attributes."""
-        return {k: v for k, v in self._dovado.state.items()
+        return {k: v for k, v in self._data.state.items()
                 if k not in ['date', 'time']}

requirements_all.txt

@@ -332,7 +332,7 @@ dlipower==0.7.165
 # homeassistant.components.doorbird
 doorbirdpy==2.0.6
 
-# homeassistant.components.sensor.dovado
+# homeassistant.components.dovado
 dovado==0.4.1
 
 # homeassistant.components.sensor.dsmr