evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Make CoolMasterNet integration async (#38643)

Browse source 
* make CoolMasteNet integration async

* Apply suggestions from code review

Co-authored-by: Chris Talkington <chris@talkingtontech.com>

* Minor post-review tweaks

* Apply suggestions from code review

* Update homeassistant/components/coolmaster/__init__.py

Co-authored-by: Chris Talkington <chris@talkingtontech.com>
This commit is contained in:
On Freund 2020-08-09 21:08:07 +03:00 • committed by GitHub
parent 597d1e2799
commit 96d48c309f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 144 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

136
homeassistant/components/coolmaster/climate.py
View file

@ -2,8 +2,6 @@
import logging
from pycoolmasternet import CoolMasterNet
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
HVAC_MODE_COOL,
@ -15,15 +13,9 @@ from homeassistant.components.climate.const import (
SUPPORT_FAN_MODE,
SUPPORT_TARGET_TEMPERATURE,
)
from homeassistant.const import (
ATTR_TEMPERATURE,
CONF_HOST,
CONF_PORT,
TEMP_CELSIUS,
TEMP_FAHRENHEIT,
)
from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT
from .const import CONF_SUPPORTED_MODES, DOMAIN
from .const import CONF_SUPPORTED_MODES, DATA_COORDINATOR, DATA_INFO, DOMAIN
SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_FAN_MODE
@ -42,58 +34,63 @@ FAN_MODES = ["low", "med", "high", "auto"]
_LOGGER = logging.getLogger(__name__)
def _build_entity(device, supported_modes):
_LOGGER.debug("Found device %s", device.uid)
return CoolmasterClimate(device, supported_modes)
def _build_entity(coordinator, unit_id, unit, supported_modes, info):
_LOGGER.debug("Found device %s", unit_id)
return CoolmasterClimate(coordinator, unit_id, unit, supported_modes, info)
async def async_setup_entry(hass, config_entry, async_add_devices):
"""Set up the CoolMasterNet climate platform."""
supported_modes = config_entry.data.get(CONF_SUPPORTED_MODES)
host = config_entry.data[CONF_HOST]
port = config_entry.data[CONF_PORT]
cool = CoolMasterNet(host, port=port)
devices = await hass.async_add_executor_job(cool.devices)
info = hass.data[DOMAIN][config_entry.entry_id][DATA_INFO]
all_devices = [_build_entity(device, supported_modes) for device in devices]
coordinator = hass.data[DOMAIN][config_entry.entry_id][DATA_COORDINATOR]
async_add_devices(all_devices, True)
all_devices = [
_build_entity(coordinator, unit_id, unit, supported_modes, info)
for (unit_id, unit) in coordinator.data.items()
]
async_add_devices(all_devices)
class CoolmasterClimate(ClimateEntity):
"""Representation of a coolmaster climate device."""
def __init__(self, device, supported_modes):
def __init__(self, coordinator, unit_id, unit, supported_modes, info):
"""Initialize the climate device."""
self._device = device
self._uid = device.uid
self._coordinator = coordinator
self._unit_id = unit_id
self._unit = unit
self._hvac_modes = supported_modes
self._hvac_mode = None
self._target_temperature = None
self._current_temperature = None
self._current_fan_mode = None
self._current_operation = None
self._on = None
self._unit = None
self._info = info
def update(self):
"""Pull state from CoolMasterNet."""
status = self._device.status
self._target_temperature = status["thermostat"]
self._current_temperature = status["temperature"]
self._current_fan_mode = status["fan_speed"]
self._on = status["is_on"]
@property
def should_poll(self):
"""No need to poll. Coordinator notifies entity of updates."""
return False
device_mode = status["mode"]
if self._on:
self._hvac_mode = CM_TO_HA_STATE[device_mode]
else:
self._hvac_mode = HVAC_MODE_OFF
@property
def available(self):
"""Return if entity is available."""
return self._coordinator.last_update_success
if status["unit"] == "celsius":
self._unit = TEMP_CELSIUS
else:
self._unit = TEMP_FAHRENHEIT
def _refresh_from_coordinator(self):
self._unit = self._coordinator.data[self._unit_id]
self.async_write_ha_state()
async def async_added_to_hass(self):
"""When entity is added to hass."""
self.async_on_remove(
self._coordinator.async_add_listener(self._refresh_from_coordinator)
)
async def async_update(self):
"""Update the entity.
Only used by the generic entity update service.
"""
await self._coordinator.async_request_refresh()
@property
def device_info(self):
@ -103,12 +100,13 @@ class CoolmasterClimate(ClimateEntity):
"name": self.name,
"manufacturer": "CoolAutomation",
"model": "CoolMasterNet",
"sw_version": self._info["version"],
}
@property
def unique_id(self):
"""Return unique ID for this device."""
return self._uid
return self._unit_id
@property
def supported_features(self):
@ -123,22 +121,30 @@ class CoolmasterClimate(ClimateEntity):
@property
def temperature_unit(self):
"""Return the unit of measurement."""
return self._unit
if self._unit.temperature_unit == "celsius":
return TEMP_CELSIUS
return TEMP_FAHRENHEIT
@property
def current_temperature(self):
"""Return the current temperature."""
return self._current_temperature
return self._unit.temperature
@property
def target_temperature(self):
"""Return the temperature we are trying to reach."""
return self._target_temperature
return self._unit.thermostat
@property
def hvac_mode(self):
"""Return hvac target hvac state."""
return self._hvac_mode
mode = self._unit.mode
is_on = self._unit.is_on
if not is_on:
return HVAC_MODE_OFF
return CM_TO_HA_STATE[mode]
@property
def hvac_modes(self):
@ -148,41 +154,45 @@ class CoolmasterClimate(ClimateEntity):
@property
def fan_mode(self):
"""Return the fan setting."""
return self._current_fan_mode
return self._unit.fan_speed
@property
def fan_modes(self):
"""Return the list of available fan modes."""
return FAN_MODES
def set_temperature(self, **kwargs):
async def async_set_temperature(self, **kwargs):
"""Set new target temperatures."""
temp = kwargs.get(ATTR_TEMPERATURE)
if temp is not None:
_LOGGER.debug("Setting temp of %s to %s", self.unique_id, str(temp))
self._device.set_thermostat(str(temp))
self._unit = await self._unit.set_thermostat(temp)
self.async_write_ha_state()
def set_fan_mode(self, fan_mode):
async def async_set_fan_mode(self, fan_mode):
"""Set new fan mode."""
_LOGGER.debug("Setting fan mode of %s to %s", self.unique_id, fan_mode)
self._device.set_fan_speed(fan_mode)
self._unit = await self._unit.set_fan_speed(fan_mode)
self.async_write_ha_state()
def set_hvac_mode(self, hvac_mode):
async def async_set_hvac_mode(self, hvac_mode):
"""Set new operation mode."""
_LOGGER.debug("Setting operation mode of %s to %s", self.unique_id, hvac_mode)
if hvac_mode == HVAC_MODE_OFF:
self.turn_off()
await self.async_turn_off()
else:
self._device.set_mode(HA_STATE_TO_CM[hvac_mode])
self.turn_on()
self._unit = await self._unit.set_mode(HA_STATE_TO_CM[hvac_mode])
await self.async_turn_on()
def turn_on(self):
async def async_turn_on(self):
"""Turn on."""
_LOGGER.debug("Turning %s on", self.unique_id)
self._device.turn_on()
self._unit = await self._unit.turn_on()
self.async_write_ha_state()
def turn_off(self):
async def async_turn_off(self):
"""Turn off."""
_LOGGER.debug("Turning %s off", self.unique_id)
self._device.turn_off()
self._unit = await self._unit.turn_off()
self.async_write_ha_state()