Low bandwidth entities

[rlippmann]

I was thinking about having low bandwidth entities for things like lights/switches for performance.

Protocols like Z-Wave/Zigbee can get overloaded by sending too much data, so avoiding actually sending something like a turn on command to a device that is already on could increase responsiveness/reliability.

I was thinking something like this:

import functools
from typing import Any

class LowBandwidthToggleMixin:
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._wrap_toggle_methods()

    def _wrap_toggle_methods(self):
        # Wrap async_turn_on
        if hasattr(self, "async_turn_on"):
            original_async_turn_on = getattr(self, "async_turn_on")
            @functools.wraps(original_async_turn_on)
            async def wrapped_async_turn_on(*args, **kwargs):
                if self.is_on:
                    return
                await original_async_turn_on(*args, **kwargs)
                self.async_write_ha_state()
            setattr(self, "async_turn_on", wrapped_async_turn_on)

        # Wrap async_turn_off
        if hasattr(self, "async_turn_off"):
            original_async_turn_off = getattr(self, "async_turn_off")
            @functools.wraps(original_async_turn_off)
            async def wrapped_async_turn_off(*args, **kwargs):
                if not self.is_on:
                    return
                await original_async_turn_off(*args, **kwargs)
                self.async_write_ha_state()
            setattr(self, "async_turn_off", wrapped_async_turn_off)

        # Wrap sync turn_on
        if hasattr(self, "turn_on"):
            original_turn_on = getattr(self, "turn_on")
            @functools.wraps(original_turn_on)
            def wrapped_turn_on(*args, **kwargs):
                if self.is_on:
                    return
                original_turn_on(*args, **kwargs)
                self.async_write_ha_state()
            setattr(self, "turn_on", wrapped_turn_on)

        # Wrap sync turn_off
        if hasattr(self, "turn_off"):
            original_turn_off = getattr(self, "turn_off")
            @functools.wraps(original_turn_off)
            def wrapped_turn_off(*args, **kwargs):
                if not self.is_on:
                    return
                original_turn_off(*args, **kwargs)
                self.async_write_ha_state()
            setattr(self, "turn_off", wrapped_turn_off)

And then subclasses could be created thusly:

in components/switch:

class LowBandwidthSwitch(LowBandwidthToggleMixing,SwitchEntity);

in components/light:

class LowBandwidthLight(LowBandwidthToggleMixin,LightEntity);

# similar code to avoid changing lights with same brightness/color/etc

and in integrations:

from homeassistant.components.light import LowBandwidthLight;
class myLight(LowBandwidthLight);

Thoughts?

[abmantis]

turn_on is also used to control brightness for example, even when the device is already on.

Also, there are situations where a device can be in an incorrect state on HA and that should not prevent the user from controlling the device. For example, an off state message from a Zigbee device could be missed due to network issues, and we still need to allow the user to turn the device on.

[rlippmann]

Well, as to the first point, you would deal with brightness, color, etc in the LowBandwidthLight class.

But, your 2nd point is a good argument for not doing this.

Perhaps a modification to group logic to try to turn on everything that is off first (and vice versa)? And, perhaps to "flatten" groups out to handle the case where you have overlapping subgroups?