Updated custom component to use new warmup api.

Author: foxy82

warmup4ie-PyPi/warmup4ie/warmup4ie.py

@@ -65,7 +65,6 @@ class Warmup4IE:
 
     def __init__(self, user, password):
         """Initialize the climate device."""
-        _LOGGER.info("Setting up Warmup4IE component")
         self._user = user
         self._password = password
         self._warmup_access_token = None
@@ -100,7 +99,6 @@ def connect(self):
         return True
 
     def get_locations(self):
-        """retrieve location ID that corrresponds to self._location_name"""
         # make sure we have an accessToken
         if self._warmup_access_token is None:
             _LOGGER.error("Access token is not set. Try calling connect first")
@@ -219,7 +217,7 @@ def update_all_devices(self):
                     key = device(location["id"], room["id"], thermostat["id"])
                     device_to_update = self._all_devices.get(key, None)
                     if device_to_update is None:
-                        _LOGGER.error("Found thermostat with SN %s, name %s in location %s ",
+                        _LOGGER.info("Found thermostat with SN %s, name %s in location %s ",
                                       thermostat["deviceSN"], room["roomName"], location["name"])
                         device_to_update = Warmup4IEDevice(
                             location["id"],
@@ -233,7 +231,7 @@ def update_all_devices(self):
                     device_to_update.update_room(room, thermostat)
         return self._all_devices
 
-    def set_override(self, room_id, temperature, hour, minute):
+    def set_override(self, room_id, temperature, until):
         if self._warmup_access_token is None:
             return
         body = {
@@ -245,7 +243,7 @@ def set_override(self, room_id, temperature, hour, minute):
                 "method": "setOverride",
                 "rooms": [room_id],
                 "temp": "{:03d}".format(int(temperature * 10)),
-                "until": "{:02}:{:02}".format(hour, minute),
+                "until": until,
                 "type": 3
             }
         }
@@ -259,7 +257,7 @@ def set_override(self, room_id, temperature, hour, minute):
             return None
         _LOGGER.info("Successfully set override, "
                      "response from server: '%s'", response.text)
-        return response.json()['message']['setOverride']['overrideDur']
+        self.update_all_devices()
 
     def _set_location_mode(self, location_id, location_mode):
         """set device to frost protection mode"""
@@ -293,6 +291,7 @@ def _set_location_mode(self, location_id, location_mode):
             return
         _LOGGER.info("Successfully set location mode to %s, response "
                      "from server: '%s'", location_mode, response.text)
+        self.update_all_devices()
 
     def _set_temperature(self, room_id, mode, temperature=None):
         # make sure the room/device is already configured
@@ -322,7 +321,7 @@ def _set_temperature(self, room_id, mode, temperature=None):
             return None
         _LOGGER.info("Successfully set room %s - mode to %s, temperature to %s "
                      "response from server: '%s'", room_id, mode, temperature, response.text)
-        return int(response.json()["message"]["targetTemp"]) / 10
+        self.update_all_devices()
 
     def set_location_to_frost(self, location_id):
         self._set_location_mode(location_id, "frost")
@@ -359,120 +358,117 @@ def __init__(self, location_id, location_name, room_id, room_name, device_id, se
         self._serial_number = serial_number
         self._warmup4ie_account = warmup4ie_account
 
-        self._target_temperature = 0
-        self._current_temperature = 0
-        self._target_temperature_low = 0
-        self._target_temperature_high = 0
-        self._floor_temperature = 0
-        self._floor_temperature_2 = 0
-        self._air_temperature = 0
-        self._away_temperature = 0
-        self._comfort_temperature = 0
-        self._cost = "0"
-        self._energy = "0"
-        self._fixed_temperature = 0
-        self._override_temperature = 0
-        self._override_duration = 0
-        self._sleep_temperature = 0
-        self._override_duration_mins = 0
-        self._away = False
-        self._on = True
-        self._run_mode = None
-        self._room_mode = None
-        self._heating_target = None
+        self.target_temperature = 0
+        self.current_temperature = 0
+        self.min_temp = 0
+        self.max_temp = 0
+        self.floor_temperature = 0
+        self.floor_temperature_2 = 0
+        self.air_temperature = 0
+        self.away_temperature = 0
+        self.comfort_temperature = 0
+        self.cost = "0"
+        self.energy = "0"
+        self.fixed_temperature = 0
+        self.override_temperature = 0
+        self.override_duration_mins = 0
+        self.sleep_temperature = 0
+        self.run_mode = None
+        self.room_mode = None
+        self.heating_target = None
 
     def get_run_mode(self):
         """return current mode, e.g. 'off', 'fixed', 'prog'."""
-        return self._run_mode
+        return self.run_mode
 
     def update_room(self, room, thermostat):
         """Update room/device data for the given room name.
 
         """
-        self._target_temperature = int(room['targetTemp']) / 10
-        self._target_temperature_low = int(thermostat['minTemp']) / 10
-        self._target_temperature_high = int(thermostat['maxTemp']) / 10
-        self._current_temperature = int(room['currentTemp']) / 10
-        self._floor_temperature = int(thermostat['floor1Temp']) / 10
-        self._floor_temperature_2 = int(thermostat['floor2Temp']) / 10
-        self._air_temperature = int(thermostat['airTemp']) / 10
-        self._away_temperature = int(room['awayTemp']) / 10
-        self._comfort_temperature = int(room['comfortTemp']) / 10
-        self._cost = room['cost']
-        self._energy = room['energy']
-        self._fixed_temperature = int(room['fixedTemp']) / 10
-        self._override_temperature = int(room['overrideTemp']) / 10
-        self._override_duration_mins = int(room['overrideDur'])
-        self._sleep_temperature = int(room['sleepTemp']) / 10
-        self._run_mode = RUN_MODE.get(room['runModeInt'], None)
-        self._room_mode = ROOM_MODE.get(room['roomModeInt'], None)
-        self._heating_target = HEATING_TARGET.get(thermostat['heatingTargetInt'], None)
+        self.target_temperature = int(room['targetTemp']) / 10
+        self.current_temperature = int(room['currentTemp']) / 10
+        self.min_temp = int(thermostat['minTemp']) / 10
+        self.max_temp = int(thermostat['maxTemp']) / 10
+        self.floor_temperature = int(thermostat['floor1Temp']) / 10
+        self.floor_temperature_2 = int(thermostat['floor2Temp']) / 10
+        self.air_temperature = int(thermostat['airTemp']) / 10
+        self.away_temperature = int(room['awayTemp']) / 10
+        self.comfort_temperature = int(room['comfortTemp']) / 10
+        self.cost = room['cost']
+        self.energy = room['energy']
+        self.fixed_temperature = int(room['fixedTemp']) / 10
+        self.override_temperature = int(room['overrideTemp']) / 10
+        self.override_duration_mins = int(room['overrideDur'])
+        self.sleep_temperature = int(room['sleepTemp']) / 10
+        self.run_mode = RUN_MODE.get(room['runModeInt'], None)
+        self.room_mode = ROOM_MODE.get(room['roomModeInt'], None)
+        self.heating_target = HEATING_TARGET.get(thermostat['heatingTargetInt'], None)
 
     def get_target_temperature(self):
         """return target temperature"""
-        return self._target_temperature
+        return self.target_temperature
 
     def get_current_temperature(self):
         """return current temperature"""
-        return self._current_temperature
+        return self.current_temperature
 
     def get_floor_temperature(self):
         """return floor temperature"""
-        return self._floor_temperature
+        return self.floor_temperature
 
     def get_floor_temperature_2(self):
         """return floor second temperature"""
-        return self._floor_temperature_2
+        return self.floor_temperature_2
 
     def get_air_temperature(self):
         """return air temperature"""
-        return self._air_temperature
+        return self.air_temperature
 
     def get_away_temperature(self):
         """return away temperature"""
-        return self._away_temperature
+        return self.away_temperature
 
     def get_comfort_temperature(self):
         """return comfort temperature"""
-        return self._comfort_temperature
+        return self.comfort_temperature
 
     def get_fixed_temperature(self):
         """return fixed temperature"""
-        return self._fixed_temperature
+        return self.fixed_temperature
 
     def get_override_temperature(self):
         """return override temperature"""
-        return self._override_temperature
+        return self.override_temperature
 
     def get_sleep_temperature(self):
         """return sleep temperature"""
-        return self._sleep_temperature
+        return self.sleep_temperature
 
     def get_energy(self):
         """return energy usage"""
-        return self._energy
+        return self.energy
 
     def get_cost(self):
         """return energy cost"""
-        return self._energy
+        return self.energy
 
     def get_override_duration_mins(self):
         """return the number of minutes the current override is set for"""
-        return self._override_duration_mins
+        return self.override_duration_mins
 
     def get_target_temperature_low(self):
         """return minimum temperature"""
-        return self._target_temperature_low
+        return self.min_temp
 
     def get_target_temperature_high(self):
         """return maximum temperature"""
-        return self._target_temperature_high
+        return self.max_temp
 
     def get_room_mode(self):
-        return self._room_mode
+        return self.room_mode
 
     def get_heating_target(self):
-        return self._heating_target
+        return self.heating_target
 
     def get_location_name(self):
         return self._location_name
@@ -499,17 +495,17 @@ def set_new_temperature(self, new_temperature):
             _LOGGER.info("Server declined to set new target temperature "
                          "to %.1f°C", new_temperature)
             return
-        self._target_temperature = returned_temp
+        self.target_temperature = returned_temp
         _LOGGER.info("Successfully set new target temperature to %.1f°C",
-                     self._target_temperature)
+                     self.target_temperature)
 
     def set_temperature_to_auto(self):
         """set device to automatic mode"""
-        self._target_temperature = self._warmup4ie_account.set_temperature_to_auto(self._room_id)
+        self.target_temperature = self._warmup4ie_account.set_temperature_to_auto(self._room_id)
 
     def set_temperature_to_manual(self):
         """set device to manual mode"""
-        self._target_temperature = self._warmup4ie_account.set_temperature_to_manual(self._room_id)
+        self.target_temperature = self._warmup4ie_account.set_temperature_to_manual(self._room_id)
 
     def set_location_to_frost(self):
         """set device to frost protection mode"""
@@ -519,5 +515,5 @@ def set_location_to_off(self):
         """ turn off device"""
         self._warmup4ie_account.set_location_to_off(self._loc_id)
 
-    def set_override(self, temperature, hour, minute):
-        self._override_duration_mins = self._warmup4ie_account.set_override(self._room_id, temperature, hour, minute)
+    def set_override(self, temperature, until):
+        self.override_duration_mins = self._warmup4ie_account.set_override(self._room_id, temperature, until)