[wip] Adding dryer and washer support

.gitignore

@@ -0,0 +1,2 @@
+.vscode/
+__pycache__/

DeviceTypes/LGAcDevice.py

@@ -0,0 +1,169 @@
+import wideq
+import logging
+
+"""General variables"""
+REQUIREMENTS = ['wideq']
+LOGGER = logging.getLogger(__name__)
+
+"""Device specific imports"""
+import time
+from .LGDevice import LGDevice
+from homeassistant.components import climate
+from homeassistant.components.climate import ClimateDevice
+from homeassistant.components.climate import const as c_const
+from wideq import ac as wideq_ac
+
+"""Implementation specific variables"""
+MODES = {
+    'HEAT': c_const.HVAC_MODE_HEAT,
+    'COOL': c_const.HVAC_MODE_COOL,
+    'FAN': c_const.HVAC_MODE_FAN_ONLY,
+    'DRY': c_const.HVAC_MODE_DRY,
+    'ACO': c_const.HVAC_MODE_HEAT_COOL,
+}
+FAN_MODES = {
+    'LOW': c_const.FAN_LOW,
+    'LOW_MID': 'low-mid',
+    'MID': c_const.FAN_MEDIUM,
+    'MID_HIGH': 'mid-high',
+    'HIGH': c_const.FAN_HIGH,
+
+    'NATURE': 'nature',
+    'POWER': 'power',
+}
+
+TRANSIENT_EXP = 5.0  # Report set temperature for 5 seconds.
+TEMP_MIN_F = 60  # Guessed from actual behavior: API reports are unreliable.
+TEMP_MAX_F = 89
+TEMP_MIN_C = 18  # Intervals read from the AC's remote control.
+TEMP_MAX_C = 30
+
+class LGAcDevice(LGDevice, ClimateDevice):
+    def __init__(self, client, max_retries, device, fahrenheit):
+        """Initialize an LG Climate Device."""
+
+        # Call LGDevice constructor
+        super().__init__(client, max_retries, device, wideq_ac.ACDevice)
+
+        # Overwrite variables
+        self._name = "lg_ac_" + device.id
+        self._fahrenheit = fahrenheit
+
+        # Store a transient temperature when we've just set it. We also
+        # store the timestamp for when we set this value.
+        self._transient_temp = None
+        self._transient_time = None
+
+    @property
+    def temperature_unit(self):
+        if self._fahrenheit:
+            return const.TEMP_FAHRENHEIT
+        else:
+            return const.TEMP_CELSIUS
+
+    @property
+    def supported_features(self):
+        return (
+            c_const.SUPPORT_TARGET_TEMPERATURE |
+            c_const.SUPPORT_FAN_MODE
+        )
+
+    @property
+    def min_temp(self):
+        if self._fahrenheit:
+            return TEMP_MIN_F
+        else:
+            return TEMP_MIN_C
+
+    @property
+    def max_temp(self):
+        if self._fahrenheit:
+            return TEMP_MAX_F
+        else:
+            return TEMP_MAX_C
+
+    @property
+    def current_temperature(self):
+        if self._state:
+            if self._fahrenheit:
+                return self._state.temp_cur_f
+            else:
+                return self._state.temp_cur_c
+
+    @property
+    def target_temperature(self):
+        # Use the recently-set target temperature if it was set recently
+        # (within TRANSIENT_EXP seconds ago).
+        if self._transient_temp:
+            interval = time.time() - self._transient_time
+            if interval < TRANSIENT_EXP:
+                return self._transient_temp
+            else:
+                self._transient_temp = None
+
+        # Otherwise, actually use the device's state.
+        if self._state:
+            if self._fahrenheit:
+                return self._state.temp_cfg_f
+            else:
+                return self._state.temp_cfg_c
+
+    @property
+    def hvac_modes(self):
+        return list(MODES.values()) + [c_const.HVAC_MODE_OFF]
+
+    @property
+    def fan_modes(self):
+        return list(FAN_MODES.values())
+
+    @property
+    def hvac_mode(self):
+        if self._state:
+            if not self._state.is_on:
+                return c_const.HVAC_MODE_OFF
+            mode = self._state.mode
+            return MODES[mode.name]
+
+    @property
+    def fan_mode(self):
+        mode = self._state.fan_speed
+        return FAN_MODES[mode.name]
+
+    def set_hvac_mode(self, hvac_mode):
+        if hvac_mode == c_const.HVAC_MODE_OFF:
+            self._wideq_device.set_on(False)
+            return
+
+        # Some AC units must be powered on before setting the mode.
+        if not self._state.is_on:
+            self._wideq_device.set_on(True)
+
+        # Invert the modes mapping.
+        modes_inv = {v: k for k, v in MODES.items()}
+
+        mode = wideq_ac.ACMode[modes_inv[hvac_mode]]
+        LOGGER.info('Setting mode to %s...', mode)
+        self._wideq_device.set_mode(mode)
+        LOGGER.info('Mode set.')
+
+    def set_fan_mode(self, fan_mode):
+        # Invert the fan modes mapping.
+        fan_modes_inv = {v: k for k, v in FAN_MODES.items()}
+
+        mode = wideq_ac.ACFanSpeed[fan_modes_inv[fan_mode]]
+        LOGGER.info('Setting fan mode to %s', fan_mode)
+        self._wideq_device.set_fan_speed(mode)
+        LOGGER.info('Fan mode set.')
+
+    def set_temperature(self, **kwargs):
+        temperature = kwargs['temperature']
+        self._transient_temp = temperature
+        self._transient_time = time.time()
+
+        LOGGER.info('Setting temperature to %s...', temperature)
+        if self._fahrenheit:
+            self._wideq_device.set_fahrenheit(temperature)
+        else:
+            self._wideq_device.set_celsius(temperature)
+        LOGGER.info('Temperature set.')
+

DeviceTypes/LGDevice.py

@@ -0,0 +1,82 @@
+import wideq
+import logging
+
+from homeassistant.helpers.entity import Entity
+
+LOGGER = logging.getLogger(__name__)
+
+class LGDevice(Entity):
+    def __init__(self, client, max_retries, device, wideq_constructor):
+        self._client = client
+        self._max_retries = max_retries
+        self._device = device
+
+        # Monitoring variables
+        self._status = None
+        self._name = "lg_device_" + device.id
+        self._failed_request_count = 0
+
+        # This constructor is called during platform creation. It must not
+        # involve any API calls that actually need the dishwasher to be
+        # connected, otherwise the device construction will fail and the entity
+        # will not get created. Specifically, calls that depend on dishwasher
+        # interaction should only happen in update(...), including the start of
+        # the monitor task.
+        self._wideq_device = wideq_constructor(client, device);
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def available(self):
+        return True
+
+    def _restart_monitor(self):
+        try:
+            self._wideq_device.monitor_start()
+        except wideq.NotConnectedError:
+            LOGGER.info('Device not available.')
+            self._status = None
+        except wideq.NotLoggedInError:
+            LOGGER.info('Session expired. Refreshing.')
+            self._client.refresh()
+
+    def update(self):
+        """Poll for wideq device state updates."""
+
+        # This method is polled, so try to avoid sleeping in here. If an error
+        # occurs, it will naturally be retried on the next poll.
+        LOGGER.debug('Updating %s.', self._name)
+
+        # On initial construction, the dishwasher monitor task
+        # will not have been created. If so, start monitoring here.
+        if getattr(self._wideq_device, 'mon', None) is None:
+            self._restart_monitor()
+
+        try:
+            status = self._wideq_device.poll()
+        except wideq.NotConnectedError:
+            self._status = None
+            return
+        except wideq.NotLoggedInError:
+            LOGGER.info('Session expired. Refreshing.')
+            self._client.refresh()
+            self._restart_monitor()
+            return
+
+        if status:
+            LOGGER.debug('Status updated.')
+            self._status = status
+            self._failed_request_count = 0
+            return
+
+        LOGGER.debug('No status available yet.')
+        self._failed_request_count += 1
+
+        if self._failed_request_count >= self._max_retries:
+            # We tried several times but got no result. This might happen
+            # when the monitoring request gets into a bad state, so we
+            # restart the task.
+            self._restart_monitor()
+            self._failed_request_count = 0

DeviceTypes/LGDishwasherDevice.py

@@ -0,0 +1,118 @@
+import wideq
+import logging
+
+"""General variables"""
+REQUIREMENTS = ['wideq']
+LOGGER = logging.getLogger(__name__)
+
+"""Device specific imports"""
+import datetime
+from .LGDevice import LGDevice
+from wideq import dishwasher as wideq_dishwasher
+
+"""Device specific variables"""
+ATTR_DW_STATE = 'state'
+ATTR_DW_REMAINING_TIME = 'remaining_time'
+ATTR_DW_REMAINING_TIME_IN_MINUTES = 'remaining_time_in_minutes'
+ATTR_DW_INITIAL_TIME = 'initial_time'
+ATTR_DW_INITIAL_TIME_IN_MINUTES = 'initial_time_in_minutes'
+ATTR_DW_RESERVE_TIME = 'reserve_time'
+ATTR_DW_RESERVE_TIME_IN_MINUTES = 'reserve_time_in_minutes'
+ATTR_DW_COURSE = 'course'
+ATTR_DW_ERROR = 'error'
+ATTR_DW_DEVICE_TYPE = 'device_type'
+KEY_DW_OFF = 'Off'
+KEY_DW_DISCONNECTED = 'Disconnected'
+
+class LGDishwasherDevice(LGDevice):
+    def __init__(self, client, max_retries, device):
+        """Initialize an LG DishWasher Device."""
+
+        # Call LGDevice constructor
+        super().__init__(client, max_retries, device, wideq_dishwasher.DishWasherDevice)
+
+        # Overwrite variables
+        self._name = "lg_dishwasher_" + device.id
+
+    @property
+    def state_attributes(self):
+        """Return the optional state attributes for the dishwasher."""
+        data = {}
+        data[ATTR_DW_REMAINING_TIME] = self.remaining_time
+        data[ATTR_DW_REMAINING_TIME_IN_MINUTES] = self.remaining_time_in_minutes
+        data[ATTR_DW_INITIAL_TIME] = self.initial_time
+        data[ATTR_DW_INITIAL_TIME_IN_MINUTES] = self.initial_time_in_minutes
+        data[ATTR_DW_RESERVE_TIME] = self.reserve_time
+        data[ATTR_DW_RESERVE_TIME_IN_MINUTES] = self.reserve_time_in_minutes
+        data[ATTR_DW_COURSE] = self.course
+        data[ATTR_DW_ERROR] = self.error
+
+        # For convenience, include the state as an attribute.
+        data[ATTR_DW_STATE] = self.state
+        return data
+
+    @property
+    def state(self):
+        if self._status:
+          # Process is a more refined string to use for state, if it's present,
+          # use it instead.
+            return self._status.readable_process or self._status.readable_state
+        return dishwasher.DISHWASHER_STATE_READABLE[dishwasher.DishWasherState.OFF.name]
+
+    @property
+    def remaining_time(self):
+        minutes = self.remaining_time_in_minutes if self._status else 0
+        return str(datetime.timedelta(minutes=minutes))[:-3]
+
+    @property
+    def remaining_time_in_minutes(self):
+        # The API (indefinitely) returns 1 minute remaining when a cycle is
+        # either in state off or complete, or process night-drying. Return 0
+        # minutes remaining in these instances, which is more reflective of
+        # reality.
+        if (self._status and
+            (self._status.process == wideq_dishwasher.DishWasherProcess.NIGHT_DRYING or
+             self._status.state == wideq_dishwasher.DishWasherState.OFF or
+             self._status.state == wideq_dishwasher.DishWasherState.COMPLETE)):
+            return 0
+        return self._status.remaining_time if self._status else 0
+
+    @property
+    def initial_time(self):
+        minutes = self.initial_time_in_minutes if self._status else 0
+        return str(datetime.timedelta(minutes=minutes))[:-3]
+
+    @property
+    def initial_time_in_minutes(self):
+        # When in state OFF, the dishwasher still returns the initial program
+        # length of the previously ran cycle. Instead, return 0 which is more
+        # reflective of the dishwasher being off.
+        if (self._status and
+            self._status.state == wideq_dishwasher.DishWasherState.OFF):
+            return 0
+        return self._status.initial_time if self._status else 0
+
+    @property
+    def reserve_time(self):
+        minutes = self.reserve_time_in_minutes if self._status else 0
+        return str(datetime.timedelta(minutes=minutes))[:-3]
+
+    @property
+    def reserve_time_in_minutes(self):
+        return self._status.reserve_time if self._status else 0
+
+    @property
+    def course(self):
+        if self._status:
+            if self._status.smart_course != KEY_DW_OFF:
+                return self._status.smart_course
+            else:
+                return self._status.course
+        return KEY_DW_OFF
+
+    @property
+    def error(self):
+        if self._status:
+            return self._status.error
+        return KEY_DW_DISCONNECTED
+