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

Simplify requests in the Broadlink integration (#58850)

Browse source
This commit is contained in:
Felipe Martins Diel 2021-11-01 08:49:00 -03:00 • committed by GitHub
parent f0bd6acd48
commit 93bc88be16
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 50 additions and 40 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
homeassistant/components/broadlink/entity.py
View file

@ -53,11 +53,13 @@ class BroadlinkEntity(Entity):
@property @property
def device_info(self) -> DeviceInfo: def device_info(self) -> DeviceInfo:
"""Return device info.""" """Return device info."""
device = self._device
return DeviceInfo( return DeviceInfo(
connections={(dr.CONNECTION_NETWORK_MAC, self._device.mac_address)}, connections={(dr.CONNECTION_NETWORK_MAC, device.mac_address)},
identifiers={(DOMAIN, self._device.unique_id)}, identifiers={(DOMAIN, device.unique_id)},
manufacturer=self._device.api.manufacturer, manufacturer=device.api.manufacturer,
model=self._device.api.model, model=device.api.model,
name=self._device.name, name=device.name,
sw_version=self._device.fw_version, sw_version=device.fw_version,
) )

6
homeassistant/components/broadlink/light.py
View file

@ -124,10 +124,10 @@ class BroadlinkLight(BroadlinkEntity, LightEntity):
async def _async_set_state(self, state): async def _async_set_state(self, state):
"""Set the state of the light.""" """Set the state of the light."""
device = self._device
try: try:
state = await self._device.async_request( state = await device.async_request(device.api.set_state, **state)
self._device.api.set_state, **state
)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to set state: %s", err) _LOGGER.error("Failed to set state: %s", err)
return return

52
homeassistant/components/broadlink/remote.py
View file

@ -213,10 +213,11 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
kwargs[ATTR_COMMAND] = command kwargs[ATTR_COMMAND] = command
kwargs = SERVICE_SEND_SCHEMA(kwargs) kwargs = SERVICE_SEND_SCHEMA(kwargs)
commands = kwargs[ATTR_COMMAND] commands = kwargs[ATTR_COMMAND]
device = kwargs.get(ATTR_DEVICE) subdevice = kwargs.get(ATTR_DEVICE)
repeat = kwargs[ATTR_NUM_REPEATS] repeat = kwargs[ATTR_NUM_REPEATS]
delay = kwargs[ATTR_DELAY_SECS] delay = kwargs[ATTR_DELAY_SECS]
service = f"{RM_DOMAIN}.{SERVICE_SEND_COMMAND}" service = f"{RM_DOMAIN}.{SERVICE_SEND_COMMAND}"
device = self._device
if not self._attr_is_on: if not self._attr_is_on:
_LOGGER.warning( _LOGGER.warning(
@ -228,13 +229,13 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await self._async_load_storage() await self._async_load_storage()
try: try:
code_list = self._extract_codes(commands, device) code_list = self._extract_codes(commands, subdevice)
except ValueError as err: except ValueError as err:
_LOGGER.error("Failed to call %s: %s", service, err) _LOGGER.error("Failed to call %s: %s", service, err)
raise raise
rf_flags = {0xB2, 0xD7} rf_flags = {0xB2, 0xD7}
if not hasattr(self._device.api, "sweep_frequency") and any( if not hasattr(device.api, "sweep_frequency") and any(
c[0] in rf_flags for codes in code_list for c in codes c[0] in rf_flags for codes in code_list for c in codes
): ):
err_msg = f"{self.entity_id} doesn't support sending RF commands" err_msg = f"{self.entity_id} doesn't support sending RF commands"
@ -247,18 +248,18 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await asyncio.sleep(delay) await asyncio.sleep(delay)
if len(codes) > 1: if len(codes) > 1:
code = codes[self._flags[device]] code = codes[self._flags[subdevice]]
else: else:
code = codes[0] code = codes[0]
try: try:
await self._device.async_request(self._device.api.send_data, code) await device.async_request(device.api.send_data, code)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.error("Error during %s: %s", service, err) _LOGGER.error("Error during %s: %s", service, err)
break break
if len(codes) > 1: if len(codes) > 1:
self._flags[device] ^= 1 self._flags[subdevice] ^= 1
at_least_one_sent = True at_least_one_sent = True
if at_least_one_sent: if at_least_one_sent:
@ -269,9 +270,10 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
kwargs = SERVICE_LEARN_SCHEMA(kwargs) kwargs = SERVICE_LEARN_SCHEMA(kwargs)
commands = kwargs[ATTR_COMMAND] commands = kwargs[ATTR_COMMAND]
command_type = kwargs[ATTR_COMMAND_TYPE] command_type = kwargs[ATTR_COMMAND_TYPE]
device = kwargs[ATTR_DEVICE] subdevice = kwargs[ATTR_DEVICE]
toggle = kwargs[ATTR_ALTERNATIVE] toggle = kwargs[ATTR_ALTERNATIVE]
service = f"{RM_DOMAIN}.{SERVICE_LEARN_COMMAND}" service = f"{RM_DOMAIN}.{SERVICE_LEARN_COMMAND}"
device = self._device
if not self._attr_is_on: if not self._attr_is_on:
_LOGGER.warning( _LOGGER.warning(
@ -286,7 +288,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
if command_type == COMMAND_TYPE_IR: if command_type == COMMAND_TYPE_IR:
learn_command = self._async_learn_ir_command learn_command = self._async_learn_ir_command
elif hasattr(self._device.api, "sweep_frequency"): elif hasattr(device.api, "sweep_frequency"):
learn_command = self._async_learn_rf_command learn_command = self._async_learn_rf_command
else: else:
@ -310,7 +312,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
_LOGGER.error("Failed to learn '%s': %s", command, err) _LOGGER.error("Failed to learn '%s': %s", command, err)
continue continue
self._codes.setdefault(device, {}).update({command: code}) self._codes.setdefault(subdevice, {}).update({command: code})
should_store = True should_store = True
if should_store: if should_store:
@ -318,8 +320,10 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
async def _async_learn_ir_command(self, command): async def _async_learn_ir_command(self, command):
"""Learn an infrared command.""" """Learn an infrared command."""
device = self._device
try: try:
await self._device.async_request(self._device.api.enter_learning) await device.async_request(device.api.enter_learning)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.debug("Failed to enter learning mode: %s", err) _LOGGER.debug("Failed to enter learning mode: %s", err)
@ -336,7 +340,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
while (dt.utcnow() - start_time) < LEARNING_TIMEOUT: while (dt.utcnow() - start_time) < LEARNING_TIMEOUT:
await asyncio.sleep(1) await asyncio.sleep(1)
try: try:
code = await self._device.async_request(self._device.api.check_data) code = await device.async_request(device.api.check_data)
except (ReadError, StorageError): except (ReadError, StorageError):
continue continue
return b64encode(code).decode("utf8") return b64encode(code).decode("utf8")
@ -353,8 +357,10 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
async def _async_learn_rf_command(self, command): async def _async_learn_rf_command(self, command):
"""Learn a radiofrequency command.""" """Learn a radiofrequency command."""
device = self._device
try: try:
await self._device.async_request(self._device.api.sweep_frequency) await device.async_request(device.api.sweep_frequency)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.debug("Failed to sweep frequency: %s", err) _LOGGER.debug("Failed to sweep frequency: %s", err)
@ -370,15 +376,11 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
start_time = dt.utcnow() start_time = dt.utcnow()
while (dt.utcnow() - start_time) < LEARNING_TIMEOUT: while (dt.utcnow() - start_time) < LEARNING_TIMEOUT:
await asyncio.sleep(1) await asyncio.sleep(1)
found = await self._device.async_request( found = await device.async_request(device.api.check_frequency)
self._device.api.check_frequency
)
if found: if found:
break break
else: else:
await self._device.async_request( await device.async_request(device.api.cancel_sweep_frequency)
self._device.api.cancel_sweep_frequency
)
raise TimeoutError( raise TimeoutError(
"No radiofrequency found within " "No radiofrequency found within "
f"{LEARNING_TIMEOUT.total_seconds()} seconds" f"{LEARNING_TIMEOUT.total_seconds()} seconds"
@ -392,7 +394,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await asyncio.sleep(1) await asyncio.sleep(1)
try: try:
await self._device.async_request(self._device.api.find_rf_packet) await device.async_request(device.api.find_rf_packet)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.debug("Failed to enter learning mode: %s", err) _LOGGER.debug("Failed to enter learning mode: %s", err)
@ -409,7 +411,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
while (dt.utcnow() - start_time) < LEARNING_TIMEOUT: while (dt.utcnow() - start_time) < LEARNING_TIMEOUT:
await asyncio.sleep(1) await asyncio.sleep(1)
try: try:
code = await self._device.async_request(self._device.api.check_data) code = await device.async_request(device.api.check_data)
except (ReadError, StorageError): except (ReadError, StorageError):
continue continue
return b64encode(code).decode("utf8") return b64encode(code).decode("utf8")
@ -428,7 +430,7 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
"""Delete a list of commands from a remote.""" """Delete a list of commands from a remote."""
kwargs = SERVICE_DELETE_SCHEMA(kwargs) kwargs = SERVICE_DELETE_SCHEMA(kwargs)
commands = kwargs[ATTR_COMMAND] commands = kwargs[ATTR_COMMAND]
device = kwargs[ATTR_DEVICE] subdevice = kwargs[ATTR_DEVICE]
service = f"{RM_DOMAIN}.{SERVICE_DELETE_COMMAND}" service = f"{RM_DOMAIN}.{SERVICE_DELETE_COMMAND}"
if not self._attr_is_on: if not self._attr_is_on:
@ -443,9 +445,9 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
await self._async_load_storage() await self._async_load_storage()
try: try:
codes = self._codes[device] codes = self._codes[subdevice]
except KeyError as err: except KeyError as err:
err_msg = f"Device not found: {repr(device)}" err_msg = f"Device not found: {repr(subdevice)}"
_LOGGER.error("Failed to call %s. %s", service, err_msg) _LOGGER.error("Failed to call %s. %s", service, err_msg)
raise ValueError(err_msg) from err raise ValueError(err_msg) from err
@ -470,8 +472,8 @@ class BroadlinkRemote(BroadlinkEntity, RemoteEntity, RestoreEntity):
# Clean up # Clean up
if not codes: if not codes:
del self._codes[device] del self._codes[subdevice]
if self._flags.pop(device, None) is not None: if self._flags.pop(subdevice, None) is not None:
self._flag_storage.async_delay_save(self._get_flags, FLAG_SAVE_DELAY) self._flag_storage.async_delay_save(self._get_flags, FLAG_SAVE_DELAY)
self._code_storage.async_delay_save(self._get_codes, CODE_SAVE_DELAY) self._code_storage.async_delay_save(self._get_codes, CODE_SAVE_DELAY)

18
homeassistant/components/broadlink/switch.py
View file

@ -179,11 +179,13 @@ class BroadlinkRMSwitch(BroadlinkSwitch):
async def _async_send_packet(self, packet): async def _async_send_packet(self, packet):
"""Send a packet to the device.""" """Send a packet to the device."""
device = self._device
if packet is None: if packet is None:
return True return True
try: try:
await self._device.async_request(self._device.api.send_data, packet) await device.async_request(device.api.send_data, packet)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err) _LOGGER.error("Failed to send packet: %s", err)
return False return False
@ -200,8 +202,10 @@ class BroadlinkSP1Switch(BroadlinkSwitch):
async def _async_send_packet(self, packet): async def _async_send_packet(self, packet):
"""Send a packet to the device.""" """Send a packet to the device."""
device = self._device
try: try:
await self._device.async_request(self._device.api.set_power, packet) await device.async_request(device.api.set_power, packet)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err) _LOGGER.error("Failed to send packet: %s", err)
return False return False
@ -242,10 +246,10 @@ class BroadlinkMP1Slot(BroadlinkSwitch):
async def _async_send_packet(self, packet): async def _async_send_packet(self, packet):
"""Send a packet to the device.""" """Send a packet to the device."""
device = self._device
try: try:
await self._device.async_request( await device.async_request(device.api.set_power, self._slot, packet)
self._device.api.set_power, self._slot, packet
)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err) _LOGGER.error("Failed to send packet: %s", err)
return False return False
@ -273,9 +277,11 @@ class BroadlinkBG1Slot(BroadlinkSwitch):
async def _async_send_packet(self, packet): async def _async_send_packet(self, packet):
"""Send a packet to the device.""" """Send a packet to the device."""
device = self._device
state = {f"pwr{self._slot}": packet} state = {f"pwr{self._slot}": packet}
try: try:
await self._device.async_request(self._device.api.set_state, **state) await device.async_request(device.api.set_state, **state)
except (BroadlinkException, OSError) as err: except (BroadlinkException, OSError) as err:
_LOGGER.error("Failed to send packet: %s", err) _LOGGER.error("Failed to send packet: %s", err)
return False return False