Make compatibele with HACS

.gitignore

@@ -1 +1,2 @@
 **/*.pyc
+.idea/

README.md

@@ -18,7 +18,7 @@ source bin/activate
 pip3 install requests_oauthlib
 ```
 
-* Following the [instructions on the Miele developer site](https://www.miele.com/developer/getinvolved.html), you need to request your personal ```ClientID``` and ```ClientSecret```.
+* Following the [instructions on the Miele developer site](https://www.miele.com/f/com/en/register_api.aspx), you need to request your personal ```ClientID``` and ```ClientSecret```.
 
 ## Installation of the custom component
 

miele/__init__.py → custom_components/miele/__init__.py

@@ -17,13 +17,10 @@
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.event import async_track_time_interval
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.network import get_url
 
 from .miele_at_home import MieleClient, MieleOAuth
 
-REQUIREMENTS = ['requests_oauthlib']
-
-DEPENDENCIES = ['http']
-
 _LOGGER = logging.getLogger(__name__)
 
 DEVICES = []
@@ -50,7 +47,7 @@
 CONFIGURATOR_SUBMIT_CAPTION = 'I have authorized Miele@home.'
 CONFIGURATOR_DESCRIPTION = 'To link your Miele account, ' \
 'click the link, login, and authorize:'
-CONFIGURATOR_DESCRIPTION_IMAGE='https://api.mcs3.miele.com/images/miele-logo-immer-besser.svg'
+CONFIGURATOR_DESCRIPTION_IMAGE='https://api.mcs3.miele.com/assets/images/miele_logo.svg'
 
 MIELE_COMPONENTS = ['binary_sensor', 'light', 'sensor']
 
@@ -80,7 +77,7 @@ async def miele_configuration_callback(callback_data):
 
     configurator = hass.components.configurator
     _CONFIGURING[DOMAIN] = configurator.async_request_config(
-        DEFAULT_NAME, 
+        DEFAULT_NAME,
         miele_configuration_callback,
         link_name=CONFIGURATOR_LINK_NAME,
         link_url=oauth.authorization_url,
@@ -108,7 +105,7 @@ async def async_setup(hass, config):
         hass.data[DOMAIN] = {}
 
     if DATA_OAUTH not in hass.data[DOMAIN]:
-        callback_url = '{}{}'.format(hass.config.api.base_url, AUTH_CALLBACK_PATH)
+        callback_url = '{}{}'.format(get_url(hass), AUTH_CALLBACK_PATH)
         cache = config[DOMAIN].get(CONF_CACHE_PATH, hass.config.path(DEFAULT_CACHE_PATH))
         hass.data[DOMAIN][DATA_OAUTH] = MieleOAuth(
             config[DOMAIN].get(CONF_CLIENT_ID), config[DOMAIN].get(CONF_CLIENT_SECRET), 
@@ -125,19 +122,20 @@ async def async_setup(hass, config):
 
     component = EntityComponent(_LOGGER, DOMAIN, hass)
 
-    client = MieleClient(hass.data[DOMAIN][DATA_OAUTH])
+    client = MieleClient(hass, hass.data[DOMAIN][DATA_OAUTH])
     hass.data[DOMAIN][DATA_CLIENT] = client
-    hass.data[DOMAIN][DATA_DEVICES] = _to_dict(client.get_devices(lang))
+    data_get_devices = await client.get_devices(lang)
+    hass.data[DOMAIN][DATA_DEVICES] = _to_dict(data_get_devices)
 
     DEVICES.extend([create_sensor(client, hass, home_device, lang) for k, home_device in hass.data[DOMAIN][DATA_DEVICES].items()])
     await component.async_add_entities(DEVICES, False)
-    
+
     for component in MIELE_COMPONENTS:
         load_platform(hass, component, DOMAIN, {}, config)
 
-    def refresh_devices(event_time):
+    async def refresh_devices(event_time):
         _LOGGER.debug("Attempting to update Miele devices")
-        device_state = client.get_devices(lang)
+        device_state = await client.get_devices(lang)
         if device_state is None:
             _LOGGER.error("Did not receive Miele devices")
         else:
@@ -290,6 +288,6 @@ async def action(self, action):
 
     async def async_update(self):        
         if not self.unique_id in self._hass.data[DOMAIN][DATA_DEVICES]:
-            _LOGGER.error('Miele device not found: {}'.format(self.unique_id))
+            _LOGGER.debug('Miele device not found: {}'.format(self.unique_id))
         else:
             self._home_device = self._hass.data[DOMAIN][DATA_DEVICES][self.unique_id]

miele/binary_sensor.py → custom_components/miele/binary_sensor.py

@@ -3,7 +3,7 @@
 from datetime import timedelta
 
 from homeassistant.helpers.entity import Entity
-from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.components.binary_sensor import BinarySensorEntity
 
 from custom_components.miele import DOMAIN as MIELE_DOMAIN, DATA_DEVICES
 
@@ -13,6 +13,7 @@
 
 ALL_DEVICES = []
 
+
 def _map_key(key):
     if key == 'signalInfo':
         return 'Info'
@@ -21,9 +22,9 @@ def _map_key(key):
     elif key == 'signalDoor':
         return 'Door'
 
+
 # pylint: disable=W0612
 def setup_platform(hass, config, add_devices, discovery_info=None):
-
     global ALL_DEVICES
 
     devices = hass.data[MIELE_DOMAIN][DATA_DEVICES]
@@ -41,11 +42,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         add_devices(binary_devices)
         ALL_DEVICES = ALL_DEVICES + binary_devices
 
+
 def update_device_state():
     for device in ALL_DEVICES:
         device.async_schedule_update_ha_state(True)
 
-class MieleBinarySensor(BinarySensorDevice):
+
+class MieleBinarySensor(BinarySensorEntity):
 
     def __init__(self, hass, device, key):
         self._hass = hass
@@ -67,7 +70,7 @@ def unique_id(self):
     def name(self):
         """Return the name of the sensor."""
         ident = self._device['ident']
-        
+
         result = ident['deviceName']
         if len(result) == 0:
             return ident['type']['value_localized'] + ' ' + self._ha_key
@@ -86,8 +89,8 @@ def device_class(self):
         else:
             return 'problem'
 
-    async def async_update(self): 
+    async def async_update(self):
         if not self.device_id in self._hass.data[MIELE_DOMAIN][DATA_DEVICES]:
-            _LOGGER.error('Miele device not found: {}'.format(self.device_id))
+            _LOGGER.debug('Miele device not found: {}'.format(self.device_id))
         else:
             self._device = self._hass.data[MIELE_DOMAIN][DATA_DEVICES][self.device_id]

miele/light.py → custom_components/miele/light.py

@@ -3,7 +3,7 @@
 from datetime import timedelta
 
 from homeassistant.helpers.entity import Entity
-from homeassistant.components.light import Light
+from homeassistant.components.light import LightEntity
 
 from custom_components.miele import DOMAIN as MIELE_DOMAIN, DATA_CLIENT, DATA_DEVICES
 
@@ -13,11 +13,11 @@
 
 ALL_DEVICES = []
 
-SUPPORTED_TYPES = [ 17, 18, 32, 33, 34, 68 ]
+SUPPORTED_TYPES = [17, 18, 32, 33, 34, 68]
+
 
 # pylint: disable=W0612
 def setup_platform(hass, config, add_devices, discovery_info=None):
-
     global ALL_DEVICES
 
     devices = hass.data[MIELE_DOMAIN][DATA_DEVICES]
@@ -31,11 +31,13 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
         add_devices(light_devices)
         ALL_DEVICES = ALL_DEVICES + light_devices
 
+
 def update_device_state():
     for device in ALL_DEVICES:
         device.async_schedule_update_ha_state(True)
 
-class MieleLight(Light):
+
+class MieleLight(LightEntity):
     def __init__(self, hass, device):
         self._hass = hass
         self._device = device
@@ -55,7 +57,7 @@ def unique_id(self):
     def name(self):
         """Return the name of the light."""
         ident = self._device['ident']
-        
+
         result = ident['deviceName']
         if len(result) == 0:
             return ident['type']['value_localized']
@@ -65,24 +67,24 @@ def name(self):
     @property
     def is_on(self):
         """Return the state of the light."""
-        return self._device['state']['light'] == 1  
+        return self._device['state']['light'] == 1
 
     def turn_on(self, **kwargs):
         service_parameters = {
             'device_id': self.device_id,
-            'body': { 'light': 1 }
+            'body': {'light': 1}
         }
         self._hass.services.call(MIELE_DOMAIN, 'action', service_parameters)
 
     def turn_off(self, **kwargs):
         service_parameters = {
             'device_id': self.device_id,
-            'body': { 'light': 2 }
+            'body': {'light': 2}
         }
         self._hass.services.call(MIELE_DOMAIN, 'action', service_parameters)
 
-    async def async_update(self): 
+    async def async_update(self):
         if not self.device_id in self._hass.data[MIELE_DOMAIN][DATA_DEVICES]:
-            _LOGGER.error('Miele device not found: {}'.format(self.device_id))
+            _LOGGER.debug('Miele device not found: {}'.format(self.device_id))
         else:
             self._device = self._hass.data[MIELE_DOMAIN][DATA_DEVICES][self.device_id]

custom_components/miele/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "miele",
+  "name": "Miele@home",
+  "documentation": "https://github.com/docbobo/home-assistant-miele",
+  "requirements": [
+    "requests_oauthlib"
+  ],
+  "dependencies": [
+    "http"
+  ],
+  "codeowners": ["docbobo, Kloknibor"]
+}

miele/miele_at_home.py → custom_components/miele/miele_at_home.py

@@ -1,5 +1,7 @@
 import json
 import logging
+import functools
+
 
 from datetime import timedelta
 
@@ -12,20 +14,22 @@ class MieleClient(object):
     DEVICES_URL = 'https://api.mcs3.miele.com/v1/devices'
     ACTION_URL = 'https://api.mcs3.miele.com/v1/devices/{0}/actions'
 
-    def __init__(self, session):
+    def __init__(self, hass, session):
         self._session = session
+        self.hass = hass
 
-    def _get_devices_raw(self, lang):
+    async def _get_devices_raw(self, lang):
         _LOGGER.debug('Requesting Miele device update')
         try:
-            devices = self._session._session.get(MieleClient.DEVICES_URL, params={'language':lang})
+            func = functools.partial(self._session._session.get, MieleClient.DEVICES_URL, params={'language':lang})
+            devices = await self.hass.async_add_executor_job(func)
             if devices.status_code == 401:
                 _LOGGER.info('Request unauthorized - attempting token refresh')
                 if self._session.refresh_token():
-                    return self._get_devices_raw(lang)    
+                    return self._get_devices_raw(lang)
 
             if devices.status_code != 200:
-                _LOGGER.error('Failed to retrieve devices: {}'.format(devices.status_code))
+                _LOGGER.debug('Failed to retrieve devices: {}'.format(devices.status_code))
                 return None
 
             return devices.json()
@@ -34,16 +38,16 @@ def _get_devices_raw(self, lang):
              _LOGGER.error('Failed to retrieve Miele devices: {0}'.format(err))
              return None
 
-    def get_devices(self, lang='en'):
-        home_devices = self._get_devices_raw(lang)
+    async def get_devices(self, lang='en'):
+        home_devices = await self._get_devices_raw(lang)
         if home_devices is None:
             return None
 
         result = []
         for home_device in home_devices:
             result.append(home_devices[home_device])
 
-        return result   
+        return result
 
     def get_device(self, device_id, lang='en'):
         devices = self._get_devices_raw(lang)
@@ -63,7 +67,7 @@ def action(self, device_id, body):
             if result.status_code == 401:
                 _LOGGER.info('Request unauthorized - attempting token refresh')
                 if self._session.refresh_token():
-                    return self.action(device_id, body)    
+                    return self.action(device_id, body)
 
             if result.status_code == 200:
                 return result.json()
@@ -95,8 +99,8 @@ def __init__(self, client_id, client_secret, redirect_uri, cache_path=None):
 
         self._session = OAuth2Session(self._client_id,
             auto_refresh_url=MieleOAuth.OAUTH_TOKEN_URL,
-            redirect_uri=redirect_uri, 
-            token=self._token, 
+            redirect_uri=redirect_uri,
+            token=self._token,
             token_updater=self._save_token)
 
         if self.authorized:
@@ -109,8 +113,8 @@ def authorized(self):
     @property
     def authorization_url(self):
         return self._session.authorization_url(MieleOAuth.OAUTH_AUTHORIZE_URL, state='login')[0]
-        
-        
+
+
     def get_access_token(self, client_code):
         token = self._session.fetch_token(
             MieleOAuth.OAUTH_TOKEN_URL,
@@ -121,13 +125,13 @@ def get_access_token(self, client_code):
 
         return token
 
-    def refresh_token(self):
+    async def refresh_token(self):
         body = 'client_id={}&client_secret={}&'.format(self._client_id, self._client_secret)
-        self._token = self._session.refresh_token(MieleOAuth.OAUTH_TOKEN_URL,
+        self._token = await self._session.refresh_token(MieleOAuth.OAUTH_TOKEN_URL,
             body=body,
             refresh_token=self._token['refresh_token'])
         self._save_token(self._token)
-            
+
     def _get_cached_token(self):
         token = None
         if self._cache_path:
@@ -139,7 +143,7 @@ def _get_cached_token(self):
 
             except IOError:
                 pass
-        
+
         return token
 
     def _save_token(self, token):