python-broadlink 1.0.0__py3-none-any.whl

broadlink/hub.py

@@ -0,0 +1,98 @@
+"""Support for hubs."""
+import json
+import struct
+from typing import Optional
+
+from . import exceptions as e
+from .device import Device
+
+
+class s3(Device):
+    """Controls a Broadlink S3."""
+
+    TYPE = "S3"
+    MAX_SUBDEVICES = 8
+
+    async def get_subdevices(self, step: int = 5) -> list:
+        """Return a list of sub devices."""
+        total = self.MAX_SUBDEVICES
+        sub_devices = []
+        seen = set()
+        index = 0
+
+        while index < total:
+            state = {"count": step, "index": index}
+            packet = self._encode(14, state)
+            resp = await self.send_packet(0x6A, packet)
+            e.check_error(resp[0x22:0x24])
+            resp = self._decode(resp)
+
+            for device in resp["list"]:
+                did = device["did"]
+                if did in seen:
+                    continue
+
+                seen.add(did)
+                sub_devices.append(device)
+
+            total = resp["total"]
+            if len(seen) >= total:
+                break
+
+            index += step
+
+        return sub_devices
+
+    async def get_state(self, did: Optional[str] = None) -> dict:
+        """Return the power state of the device."""
+        state = {}
+        if did is not None:
+            state["did"] = did
+
+        packet = self._encode(1, state)
+        response = await self.send_packet(0x6A, packet)
+        e.check_error(response[0x22:0x24])
+        return self._decode(response)
+
+    async def set_state(
+        self,
+        did: Optional[str] = None,
+        pwr1: Optional[bool] = None,
+        pwr2: Optional[bool] = None,
+        pwr3: Optional[bool] = None,
+    ) -> dict:
+        """Set the power state of the device."""
+        state = {}
+        if did is not None:
+            state["did"] = did
+        if pwr1 is not None:
+            state["pwr1"] = int(bool(pwr1))
+        if pwr2 is not None:
+            state["pwr2"] = int(bool(pwr2))
+        if pwr3 is not None:
+            state["pwr3"] = int(bool(pwr3))
+
+        packet = self._encode(2, state)
+        response = await self.send_packet(0x6A, packet)
+        e.check_error(response[0x22:0x24])
+        return self._decode(response)
+
+    def _encode(self, flag: int, state: dict) -> bytes:
+        """Encode a JSON packet."""
+        # flag: 1 for reading, 2 for writing.
+        packet = bytearray(12)
+        data = json.dumps(state, separators=(",", ":")).encode()
+        struct.pack_into(
+            "<HHHBBI", packet, 0, 0xA5A5, 0x5A5A, 0, flag, 0x0B, len(data)
+        )
+        packet.extend(data)
+        checksum = sum(packet, 0xBEAF) & 0xFFFF
+        packet[0x04:0x06] = checksum.to_bytes(2, "little")
+        return packet
+
+    def _decode(self, response: bytes) -> dict:
+        """Decode a JSON packet."""
+        payload = self.decrypt(response[0x38:])
+        js_len = struct.unpack_from("<I", payload, 0x08)[0]
+        state = json.loads(payload[0x0C:0x0C+js_len])
+        return state

broadlink/light.py

@@ -0,0 +1,200 @@
+"""Support for lights."""
+import enum
+import json
+import struct
+from typing import Optional
+
+from . import exceptions as e
+from .device import Device
+
+
+class lb1(Device):
+    """Controls a Broadlink LB1."""
+
+    TYPE = "LB1"
+
+    @enum.unique
+    class ColorMode(enum.IntEnum):
+        """Enumerates color modes."""
+
+        RGB = 0
+        WHITE = 1
+        SCENE = 2
+
+    async def get_state(self) -> dict:
+        """Return the power state of the device.
+
+        Example: `{'red': 128, 'blue': 255, 'green': 128, 'pwr': 1, 'brightness': 75, 'colortemp': 2700, 'hue': 240, 'saturation': 50, 'transitionduration': 1500, 'maxworktime': 0, 'bulb_colormode': 1, 'bulb_scenes': '["@01686464,0,0,0", "#ffffff,10,0,#000000,190,0,0", "2700+100,0,0,0", "#ff0000,500,2500,#00FF00,500,2500,#0000FF,500,2500,0", "@01686464,100,2400,@01686401,100,2400,0", "@01686464,100,2400,@01686401,100,2400,@005a6464,100,2400,@005a6401,100,2400,0", "@01686464,10,0,@00000000,190,0,0", "@01686464,200,0,@005a6464,200,0,0"]', 'bulb_scene': '', 'bulb_sceneidx': 255}`
+        """
+        packet = self._encode(1, {})
+        response = await self.send_packet(0x6A, packet)
+        e.check_error(response[0x22:0x24])
+        return self._decode(response)
+
+    async def set_state(
+        self,
+        pwr: Optional[bool] = None,
+        red: Optional[int] = None,
+        blue: Optional[int] = None,
+        green: Optional[int] = None,
+        brightness: Optional[int] = None,
+        colortemp: Optional[int] = None,
+        hue: Optional[int] = None,
+        saturation: Optional[int] = None,
+        transitionduration: Optional[int] = None,
+        maxworktime: Optional[int] = None,
+        bulb_colormode: Optional[int] = None,
+        bulb_scenes: Optional[str] = None,
+        bulb_scene: Optional[str] = None,
+        bulb_sceneidx: Optional[int] = None,
+    ) -> dict:
+        """Set the power state of the device."""
+        state = {}
+        if pwr is not None:
+            state["pwr"] = int(bool(pwr))
+        if red is not None:
+            state["red"] = int(red)
+        if blue is not None:
+            state["blue"] = int(blue)
+        if green is not None:
+            state["green"] = int(green)
+        if brightness is not None:
+            state["brightness"] = int(brightness)
+        if colortemp is not None:
+            state["colortemp"] = int(colortemp)
+        if hue is not None:
+            state["hue"] = int(hue)
+        if saturation is not None:
+            state["saturation"] = int(saturation)
+        if transitionduration is not None:
+            state["transitionduration"] = int(transitionduration)
+        if maxworktime is not None:
+            state["maxworktime"] = int(maxworktime)
+        if bulb_colormode is not None:
+            state["bulb_colormode"] = int(bulb_colormode)
+        if bulb_scenes is not None:
+            state["bulb_scenes"] = str(bulb_scenes)
+        if bulb_scene is not None:
+            state["bulb_scene"] = str(bulb_scene)
+        if bulb_sceneidx is not None:
+            state["bulb_sceneidx"] = int(bulb_sceneidx)
+
+        packet = self._encode(2, state)
+        response = await self.send_packet(0x6A, packet)
+        e.check_error(response[0x22:0x24])
+        return self._decode(response)
+
+    def _encode(self, flag: int, state: dict) -> bytes:
+        """Encode a JSON packet."""
+        # flag: 1 for reading, 2 for writing.
+        packet = bytearray(14)
+        data = json.dumps(state, separators=(",", ":")).encode()
+        p_len = 12 + len(data)
+        struct.pack_into(
+            "<HHHHBBI", packet, 0, p_len, 0xA5A5, 0x5A5A, 0, flag, 0x0B, len(data)
+        )
+        packet.extend(data)
+        checksum = sum(packet[0x02:], 0xBEAF) & 0xFFFF
+        packet[0x06:0x08] = checksum.to_bytes(2, "little")
+        return packet
+
+    def _decode(self, response: bytes) -> dict:
+        """Decode a JSON packet."""
+        payload = self.decrypt(response[0x38:])
+        js_len = struct.unpack_from("<I", payload, 0xA)[0]
+        state = json.loads(payload[0xE:0xE+js_len])
+        return state
+
+
+class lb2(Device):
+    """Controls a Broadlink LB26/LB27."""
+
+    TYPE = "LB2"
+
+    @enum.unique
+    class ColorMode(enum.IntEnum):
+        """Enumerates color modes."""
+
+        RGB = 0
+        WHITE = 1
+        SCENE = 2
+
+    async def get_state(self) -> dict:
+        """Return the power state of the device.
+
+        Example: `{'red': 128, 'blue': 255, 'green': 128, 'pwr': 1, 'brightness': 75, 'colortemp': 2700, 'hue': 240, 'saturation': 50, 'transitionduration': 1500, 'maxworktime': 0, 'bulb_colormode': 1, 'bulb_scenes': '["@01686464,0,0,0", "#ffffff,10,0,#000000,190,0,0", "2700+100,0,0,0", "#ff0000,500,2500,#00FF00,500,2500,#0000FF,500,2500,0", "@01686464,100,2400,@01686401,100,2400,0", "@01686464,100,2400,@01686401,100,2400,@005a6464,100,2400,@005a6401,100,2400,0", "@01686464,10,0,@00000000,190,0,0", "@01686464,200,0,@005a6464,200,0,0"]', 'bulb_scene': ''}`
+        """
+        packet = self._encode(1, {})
+        response = await self.send_packet(0x6A, packet)
+        e.check_error(response[0x22:0x24])
+        return self._decode(response)
+
+    async def set_state(
+        self,
+        pwr: Optional[bool] = None,
+        red: Optional[int] = None,
+        blue: Optional[int] = None,
+        green: Optional[int] = None,
+        brightness: Optional[int] = None,
+        colortemp: Optional[int] = None,
+        hue: Optional[int] = None,
+        saturation: Optional[int] = None,
+        transitionduration: Optional[int] = None,
+        maxworktime: Optional[int] = None,
+        bulb_colormode: Optional[int] = None,
+        bulb_scenes: Optional[str] = None,
+        bulb_scene: Optional[str] = None,
+    ) -> dict:
+        """Set the power state of the device."""
+        state = {}
+        if pwr is not None:
+            state["pwr"] = int(bool(pwr))
+        if red is not None:
+            state["red"] = int(red)
+        if blue is not None:
+            state["blue"] = int(blue)
+        if green is not None:
+            state["green"] = int(green)
+        if brightness is not None:
+            state["brightness"] = int(brightness)
+        if colortemp is not None:
+            state["colortemp"] = int(colortemp)
+        if hue is not None:
+            state["hue"] = int(hue)
+        if saturation is not None:
+            state["saturation"] = int(saturation)
+        if transitionduration is not None:
+            state["transitionduration"] = int(transitionduration)
+        if maxworktime is not None:
+            state["maxworktime"] = int(maxworktime)
+        if bulb_colormode is not None:
+            state["bulb_colormode"] = int(bulb_colormode)
+        if bulb_scenes is not None:
+            state["bulb_scenes"] = str(bulb_scenes)
+        if bulb_scene is not None:
+            state["bulb_scene"] = str(bulb_scene)
+
+        packet = self._encode(2, state)
+        response = await self.send_packet(0x6A, packet)
+        e.check_error(response[0x22:0x24])
+        return self._decode(response)
+
+    def _encode(self, flag: int, state: dict) -> bytes:
+        """Encode a JSON packet."""
+        # flag: 1 for reading, 2 for writing.
+        packet = bytearray(12)
+        data = json.dumps(state, separators=(",", ":")).encode()
+        struct.pack_into(
+            "<HHHBBI", packet, 0, 0xA5A5, 0x5A5A, 0, flag, 0x0B, len(data)
+        )
+        packet.extend(data)
+        checksum = sum(packet, 0xBEAF) & 0xFFFF
+        packet[0x04:0x06] = checksum.to_bytes(2, "little")
+        return packet
+
+    def _decode(self, response: bytes) -> dict:
+        """Decode a JSON packet."""
+        payload = self.decrypt(response[0x38:])
+        js_len = struct.unpack_from("<I", payload, 0x08)[0]
+        state = json.loads(payload[0x0C:0x0C+js_len])
+        return state

broadlink/protocol.py

@@ -0,0 +1,50 @@
+"""The networking part of the python-broadlink library."""
+import datetime as dt
+import time
+
+
+class Datetime:
+    """Helps to pack and unpack datetime objects for the Broadlink protocol."""
+
+    @staticmethod
+    def pack(datetime: dt.datetime) -> bytes:
+        """Pack the timestamp to be sent over the Broadlink protocol."""
+        data = bytearray(12)
+        utcoffset = int(datetime.utcoffset().total_seconds() / 3600)
+        data[:0x04] = utcoffset.to_bytes(4, "little", signed=True)
+        data[0x04:0x06] = datetime.year.to_bytes(2, "little")
+        data[0x06] = datetime.minute
+        data[0x07] = datetime.hour
+        data[0x08] = int(datetime.strftime("%y"))
+        data[0x09] = datetime.isoweekday()
+        data[0x0A] = datetime.day
+        data[0x0B] = datetime.month
+        return data
+
+    @staticmethod
+    def unpack(data: bytes) -> dt.datetime:
+        """Unpack a timestamp received over the Broadlink protocol."""
+        utcoffset = int.from_bytes(data[0x00:0x04], "little", signed=True)
+        year = int.from_bytes(data[0x04:0x06], "little")
+        minute = data[0x06]
+        hour = data[0x07]
+        subyear = data[0x08]
+        isoweekday = data[0x09]
+        day = data[0x0A]
+        month = data[0x0B]
+
+        tz_info = dt.timezone(dt.timedelta(hours=utcoffset))
+        datetime = dt.datetime(year, month, day, hour, minute, 0, 0, tz_info)
+
+        if datetime.isoweekday() != isoweekday:
+            raise ValueError("isoweekday does not match")
+        if int(datetime.strftime("%y")) != subyear:
+            raise ValueError("subyear does not match")
+
+        return datetime
+
+    @staticmethod
+    def now() -> dt.datetime:
+        """Return the current date and time with timezone info."""
+        tz_info = dt.timezone(dt.timedelta(seconds=-time.timezone))
+        return dt.datetime.now(tz_info)