python-rako-2025 0.0.1__py3-none-any.whl

python_rako/__init__.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import socket
+from asyncio.trsock import TransportSocket  # noqa
+from typing import TypedDict
+
+import asyncio_dgram
+
+from python_rako.bridge import Bridge, BridgeCommanderHTTP, BridgeCommanderUDP  # noqa
+from python_rako.const import RAKO_BRIDGE_DEFAULT_PORT, MessageType, RequestType  # noqa
+from python_rako.exceptions import RakoBridgeError  # noqa
+from python_rako.model import (  # noqa
+    BridgeInfo,
+    ChannelLight,
+    ChannelStatusMessage,
+    LevelCache,
+    LevelCacheItem,
+    Light,
+    RoomChannel,
+    RoomLight,
+    SceneCache,
+    SceneStatusMessage,
+    UnsupportedMessage,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BridgeDescription(TypedDict, total=False):
+    host: str
+    port: int
+    name: str
+    mac: str
+
+
+async def discover_bridge() -> BridgeDescription:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    server = await asyncio_dgram.from_socket(sock)
+    await server.send(b"D", ("255.255.255.255", RAKO_BRIDGE_DEFAULT_PORT))
+    msg, (host, port) = await server.recv()
+    bridge_description: BridgeDescription = {"host": host, "port": port}
+    try:
+        name, mac = msg.decode("utf8").split()
+        bridge_description["name"] = name
+        bridge_description["mac"] = mac
+    except ValueError:
+        raise ValueError(f"Couldn't interpret discovery response message: {msg}")
+    return bridge_description
+
+
+def main() -> None:
+    bridge_desc: BridgeDescription = asyncio.run(discover_bridge())
+    print(bridge_desc)
+
+
+if __name__ == "__main__":
+    main()

python_rako/__version__.py

@@ -0,0 +1,2 @@
+"""AUTOGENERATED ON RELEASE."""
+__version__ = "0.0.1"

python_rako/bridge.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, AsyncGenerator, Generator, Tuple
+
+import aiohttp
+import xmltodict
+from asyncio_dgram.aio import DatagramServer
+
+from python_rako.const import (
+    COMMAND_SUCCESS_RESPONSE,
+    CommandType,
+    Flags,
+    MessageType,
+    RequestType,
+)
+from python_rako.exceptions import RakoBridgeError
+from python_rako.helpers import (
+    command_to_byte_list,
+    deserialise_byte_list,
+    get_dg_commander,
+)
+from python_rako.model import (
+    BridgeInfo,
+    ChannelLight,
+    CommandHTTP,
+    CommandLevelHTTP,
+    CommandSceneHTTP,
+    CommandUDP,
+    EOFResponse,
+    LevelCache,
+    Light,
+    RoomLight,
+    SceneCache,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class _BridgeCommander:
+    def __init__(self, host: str, port: int):
+        self.host = host
+        self.port = port
+
+    async def set_room_scene(self, room_id: int, scene: int) -> None:
+        """Set the scene of a room."""
+        raise NotImplementedError()
+
+    async def set_room_brightness(self, room_id: int, brightness: int) -> None:
+        """Set the brightness of a room."""
+        await self.set_channel_brightness(room_id, 0, brightness)
+
+    async def set_channel_brightness(
+        self, room_id: int, channel_id: int, brightness: int
+    ) -> None:
+        """Set the brightness of a channel."""
+        raise NotImplementedError()
+
+
+class BridgeCommanderUDP(_BridgeCommander):
+    async def set_room_scene(self, room_id: int, scene: int) -> None:
+        """Set the scene of a room."""
+        command = CommandUDP(
+            room=room_id,
+            channel=0,
+            command=CommandType.SET_SCENE,
+            data=[Flags.USE_DEFAULT_FADE_RATE.value, scene],
+        )
+        await self._send_command(command)
+
+    async def set_channel_brightness(
+        self, room_id: int, channel_id: int, brightness: int
+    ) -> None:
+        """Set the brightness of a channel."""
+        command = CommandUDP(
+            room=room_id,
+            channel=channel_id,
+            command=CommandType.SET_LEVEL,
+            data=[Flags.USE_DEFAULT_FADE_RATE.value, brightness],
+        )
+        await self._send_command(command)
+
+    async def _send_command(self, command: CommandUDP) -> None:
+        _LOGGER.debug("Sending command: %s", command)
+        byte_list = command_to_byte_list(command)
+        async with get_dg_commander(self.host, self.port) as dg_client:
+            _LOGGER.debug("Sending command bytes: %s", byte_list)
+            await dg_client.send(bytes(byte_list))
+            data, _ = await dg_client.recv()
+
+        if data.decode("utf8").strip() != COMMAND_SUCCESS_RESPONSE:
+            _LOGGER.warning("Bad response after command %s %s", command, data)
+
+
+class BridgeCommanderHTTP(_BridgeCommander):
+    def __init__(self, host: str, port: int, aiohttp_session: aiohttp.ClientSession):
+        super().__init__(host, port)
+        self.aiohttp_session = aiohttp_session
+
+    @property
+    def _command_url(self) -> str:
+        return f"http://{self.host}/rako.cgi"
+
+    async def set_room_scene(self, room_id: int, scene: int) -> None:
+        """Set the scene of a room."""
+        command = CommandSceneHTTP(
+            room=room_id,
+            channel=0,
+            scene=scene,
+        )
+        await self._send_command(command)
+
+    async def set_channel_brightness(
+        self, room_id: int, channel_id: int, brightness: int
+    ) -> None:
+        """Set the brightness of a channel."""
+        command = CommandLevelHTTP(
+            room=room_id,
+            channel=channel_id,
+            level=brightness,
+        )
+        await self._send_command(command)
+
+    async def _send_command(self, command: CommandHTTP) -> None:
+        params = command.as_params()
+        _LOGGER.debug("Posting params %s", params)
+        await self.aiohttp_session.post(self._command_url, params=params)
+
+
+class Bridge:
+    def __init__(
+        self,
+        host: str,
+        port: int,
+        name: str,
+        mac: str,
+        bridge_commander: _BridgeCommander | None = None,
+    ):
+        self.host = host
+        self.port = port
+        self.name = name
+        self.mac = mac
+        self._bridge_commander = (
+            bridge_commander if bridge_commander else BridgeCommanderUDP(host, port)
+        )
+        self.level_cache: LevelCache = LevelCache()
+        self.scene_cache: SceneCache = SceneCache()
+
+    @property
+    def _discovery_url(self) -> str:
+        return f"http://{self.host}/rako.xml"
+
+    async def get_rako_xml(self, session: aiohttp.ClientSession) -> str:
+        async with session.get(self._discovery_url) as response:
+            rako_xml: str = await response.text()
+        return rako_xml
+
+    async def discover_lights(
+        self, session: aiohttp.ClientSession
+    ) -> AsyncGenerator[Light, None]:
+        rako_xml = await self.get_rako_xml(session)
+        for light in self.get_lights_from_discovery_xml(rako_xml):
+            yield light
+
+    async def get_info(self, session: aiohttp.ClientSession) -> BridgeInfo:
+        try:
+            rako_xml = await self.get_rako_xml(session)
+            info = self.get_bridge_info_from_discovery_xml(rako_xml)
+        except (KeyError, ValueError) as ex:
+            raise RakoBridgeError(f"unsupported bridge: {ex}")
+        except aiohttp.ClientError as ex:
+            raise RakoBridgeError(f"cannot connect to bridge: {ex}")
+        return info
+
+    @staticmethod
+    def get_bridge_info_from_discovery_xml(xml: str) -> BridgeInfo:
+        xml_dict = xmltodict.parse(xml)
+        info = xml_dict["rako"].get("info", dict())
+        config = xml_dict["rako"].get("config", dict())
+        return BridgeInfo(
+            version=info.get("version"),
+            buildDate=info.get("buildDate"),
+            hostName=info.get("hostName"),
+            hostIP=info.get("hostIP"),
+            hostMAC=info.get("hostMAC"),
+            hwStatus=info.get("hwStatus"),
+            dbVersion=info.get("dbVersion"),
+            requirepassword=config.get("requirepassword"),
+            passhash=config.get("passhash"),
+            charset=config.get("charset"),
+        )
+
+    @staticmethod
+    def get_lights_from_discovery_xml(xml: str) -> Generator[Light, None, None]:
+        xml_dict = xmltodict.parse(xml, force_list={'Room'})
+        for room in xml_dict["rako"]["rooms"]["Room"]:
+            room_id = int(room["@id"])
+            room_type = room.get("Type", "Lights")
+            if room_type != "Lights":
+                _LOGGER.info(
+                    "Unsupported room type. room_id=%s room_type=%s", room_id, room_type
+                )
+                continue
+            room_title = room["Title"]
+            yield RoomLight(room_id, room_title)
+            channels_section = room.get("Channel", [])
+            channels = (
+                channels_section
+                if isinstance(channels_section, list)
+                else [channels_section]
+            )
+            for channel in channels:
+                channel_id = int(channel["@id"])
+                channel_type = channel.get("type", "Default")
+                channel_name = channel["Name"]
+                channel_levels = channel["Levels"]
+                yield ChannelLight(
+                    room_id,
+                    room_title,
+                    channel_id,
+                    channel_type,
+                    channel_name,
+                    channel_levels,
+                )
+
+    async def next_pushed_message(self, dg_listener: DatagramServer) -> Any | None:
+        resp = await dg_listener.recv()
+        if not resp:
+            return None
+
+        data, (remote_ip, _) = resp
+        if remote_ip != self.host:
+            return None
+
+        byte_list = list(data)
+        _LOGGER.debug("Received bytes: %s", byte_list)
+        message = deserialise_byte_list(byte_list)
+        _LOGGER.debug("Deserialised received message as: %s", message)
+        return message
+
+    async def get_cache_state(
+        self, cache_type: RequestType = RequestType.SCENE_LEVEL_CACHE
+    ) -> Tuple[LevelCache, SceneCache]:
+        scene_cache = SceneCache()
+        level_cache = LevelCache()
+        async with get_dg_commander(self.host, self.port) as dg_client:
+            _LOGGER.debug("Requesting cache: %s", cache_type)
+            await dg_client.send(bytes([MessageType.QUERY.value, cache_type.value]))
+
+            while True:
+                try:
+                    data, _ = await asyncio.wait_for(dg_client.recv(), timeout=2.0)
+                except asyncio.TimeoutError:
+                    _LOGGER.warning("Timeout waiting for cache response")
+                    break
+
+                response = deserialise_byte_list(list(data))
+                if isinstance(response, EOFResponse):
+                    break
+                if isinstance(response, SceneCache):
+                    scene_cache = response
+                if isinstance(response, LevelCache):
+                    level_cache = response
+                _LOGGER.debug("Cache response: %s", response)
+
+        return level_cache, scene_cache
+
+    async def set_room_scene(self, room_id: int, scene: int) -> None:
+        """Set the scene of a room."""
+        await self._bridge_commander.set_room_scene(room_id, scene)
+
+    async def set_room_brightness(self, room_id: int, brightness: int) -> None:
+        """Set the brightness of a room."""
+        await self._bridge_commander.set_room_brightness(room_id, brightness)
+
+    async def set_channel_brightness(
+        self, room_id: int, channel_id: int, brightness: int
+    ) -> None:
+        """Set the brightness of a channel."""
+        await self._bridge_commander.set_channel_brightness(
+            room_id, channel_id, brightness
+        )

python_rako/const.py

@@ -0,0 +1,59 @@
+from enum import Enum
+
+RAKO_BRIDGE_DEFAULT_PORT = 9761
+sentinel = object()
+
+
+class MessageType(Enum):
+    QUERY = ord("Q")  # 81
+    SCENE_CACHE = ord("C")  # 67
+    LEVEL_CACHE = ord("X")  # 88
+    REQUEST = ord("R")  # 82
+    STATUS = ord("S")  # 83
+
+
+class DataRecordType(Enum):
+    DATA = 4
+    EOF = 255
+
+
+class RequestType(Enum):
+    SCENE_CACHE = 1
+    LEVEL_CACHE = 32
+    SCENE_LEVEL_CACHE = 33
+
+
+class Flags(Enum):
+    USE_DEFAULT_FADE_RATE = 1
+
+
+class CommandType(Enum):
+    OFF = 0
+    # FADE_UP = 1  # unsupported
+    # FADE_DOWN = 2  # unsupported
+    SC1_LEGACY = 3
+    SC2_LEGACY = 4
+    SC3_LEGACY = 5
+    SC4_LEGACY = 6
+    # IDENT = 8  # unsupported
+    LEVEL_SET_LEGACY = 12
+    # STORE = 13  # unsupported
+    # STOP_FADING = 15  # unsupported
+    # CUSTOM_232 = 45  # unsupported
+    # HOLIDAY = 47  # unsupported
+    SET_SCENE = 49
+    # FADE = 50  # unsupported
+    SET_LEVEL = 52
+
+
+COMMAND_SUCCESS_RESPONSE = "AOK"
+
+
+SCENE_NUMBER_TO_COMMAND = {
+    1: CommandType.SC1_LEGACY,
+    2: CommandType.SC2_LEGACY,
+    3: CommandType.SC3_LEGACY,
+    4: CommandType.SC4_LEGACY,
+    0: CommandType.OFF,
+}
+SCENE_COMMAND_TO_NUMBER = {v: k for k, v in SCENE_NUMBER_TO_COMMAND.items()}

python_rako/exceptions.py

@@ -0,0 +1,2 @@
+class RakoBridgeError(Exception):
+    pass

python_rako/helpers.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+from typing import AsyncIterator
+
+import asyncio_dgram
+from asyncio_dgram.aio import DatagramClient, DatagramServer
+
+from python_rako.const import (
+    SCENE_COMMAND_TO_NUMBER,
+    CommandType,
+    DataRecordType,
+    MessageType,
+    sentinel,
+)
+from python_rako.model import (
+    ChannelStatusMessage,
+    CommandUDP,
+    EOFResponse,
+    LevelCache,
+    LevelCacheItem,
+    RoomChannel,
+    SceneCache,
+    SceneStatusMessage,
+    StatusMessage,
+    UnsupportedMessage,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def get_dg_listener(
+    port: int, listen_host: str = "0.0.0.0"
+) -> AsyncIterator[DatagramServer]:
+    server: DatagramServer = None
+    try:
+        server = await asyncio_dgram.bind((listen_host, port))
+        yield server
+    finally:
+        if server:
+            server.close()
+
+
+@asynccontextmanager
+async def get_dg_commander(host: str, port: int) -> AsyncIterator[DatagramClient]:
+    client: DatagramClient = None
+    try:
+        client = await asyncio_dgram.connect((host, port))
+        yield client
+    finally:
+        if client:
+            client.close()
+
+
+def deserialise_byte_list(
+    byte_list: list[int],
+) -> UnsupportedMessage | EOFResponse | StatusMessage | SceneCache | LevelCache:
+    try:
+        message_type = MessageType(byte_list[0])
+    except ValueError:
+        _LOGGER.warning("Unsupported UDP message type byte_list=%s", byte_list)
+        return UnsupportedMessage()
+
+    try:
+        if message_type == MessageType.STATUS:
+            return deserialise_status_message(byte_list)
+
+        if message_type == MessageType.SCENE_CACHE:
+            return deserialise_scene_cache_message(byte_list)
+
+        if message_type == MessageType.LEVEL_CACHE:
+            if byte_list[1] == DataRecordType.EOF.value:
+                return EOFResponse()
+            if byte_list[1] == DataRecordType.DATA.value:
+                return deserialise_level_cache_message(byte_list)
+    except (ValueError, KeyError):
+        _LOGGER.warning(
+            "Unsupported UDP message: message_type=%s, byte_list=%s",
+            message_type,
+            byte_list,
+        )
+    return UnsupportedMessage()
+
+
+def deserialise_status_message(byte_list: list[int]) -> StatusMessage:
+    data_length = byte_list[1] - 5
+    room = byte_list[2] * 256 + byte_list[3]
+    channel = byte_list[4]
+    command = CommandType(byte_list[5])
+    data = byte_list[6 : 6 + data_length]
+    if command in (CommandType.LEVEL_SET_LEGACY, CommandType.SET_LEVEL):
+        return ChannelStatusMessage(
+            room=room,
+            channel=channel,
+            brightness=data[1],
+        )
+
+    if command == CommandType.SET_SCENE:
+        scene = data[1]
+    else:
+        # command is one of SC1_LEGACY, SC2_LEGACY, SC3_LEGACY, SC4_LEGACY
+        scene = SCENE_COMMAND_TO_NUMBER[command]
+
+    return SceneStatusMessage(
+        room=room,
+        channel=channel,
+        scene=scene,
+    )
+
+
+def deserialise_level_cache_message(byte_list: list[int]) -> LevelCache:
+    scene_cache: dict[RoomChannel, LevelCacheItem] = {}
+    it = iter(byte_list)
+    next(it)  # message type
+    for b in it:
+        if b != DataRecordType.DATA.value:
+            break
+        lc = LevelCacheItem(
+            next(it), next(it), next(it), {i: next(it) for i in range(1, 18, 1)}
+        )
+        scene_cache[RoomChannel(lc.room, lc.channel)] = lc
+    return LevelCache(scene_cache)
+
+
+def deserialise_scene_cache_message(byte_list: list[int]) -> SceneCache:
+    scene_cache = SceneCache()
+    it = iter(byte_list)
+    next(it)  # message type
+    next(it)  # undocumented. following bytes?
+    for b in it:
+        room = next(it, sentinel)
+        if room == sentinel:
+            continue
+        scene_cache[room] = int(b / 4)  # type: ignore # pylint: disable=E1137
+    return scene_cache
+
+
+def calc_crc(byte_list: list[int]) -> int:
+    return 256 - sum(byte_list) % 256
+
+
+def command_to_byte_list(command: CommandUDP) -> list[int]:
+    checksum_list: list[int] = [
+        5 + len(command.data),  # following bytes
+        int(command.room / 256),  # high room number
+        command.room % 256,  # low room number
+        command.channel,  # channel
+        command.command.value,  # command
+    ] + command.data
+
+    byte_list: list[int] = (
+        [
+            command.message_type.value,
+        ]
+        + checksum_list
+        + [
+            calc_crc(checksum_list),
+        ]
+    )
+
+    return byte_list
+
+
+_scene_brightness = {
+    # rako_scene_number: brightness
+    1: 255,
+    2: 192,
+    3: 128,
+    4: 64,
+    0: 0,
+}
+
+
+def convert_to_brightness(scene_number: int) -> int:
+    # scenes can exist outside of 0-4.
+    # rather than KeyError, lets return mid-level brightness
+    return _scene_brightness.get(scene_number, 128)
+
+
+_scene_windows = {
+    # rako_scene: (brightness_high, brightness_low)
+    1: dict(low=224, high=256),  # expect 255 (100%)
+    2: dict(low=160, high=224),  # expect 192 (75%)
+    3: dict(low=96, high=160),  # expect 128 (50%)
+    4: dict(low=1, high=96),  # expect 64 (25%)
+    0: dict(low=0, high=1),  # expect 0 (0%)
+}
+
+
+def convert_to_scene(brightness: int) -> int:
+    """
+    Return the rako scene of the light.
+
+    This directly corresponds to the value of the button on the app and is accessed through the
+    brightness
+    :param brightness: int representing brightness 0-255
+    """
+
+    scene = [
+        k for k, v in _scene_windows.items() if v["low"] <= brightness < v["high"]
+    ][0]
+    return scene

python_rako/model.py

@@ -0,0 +1,148 @@
+from dataclasses import dataclass
+from typing import Iterable
+
+from python_rako.const import CommandType, MessageType
+
+
+@dataclass(frozen=True)
+class RoomChannel:
+    room_id: int
+    channel_id: int
+
+
+@dataclass
+class Light:
+    room_id: int
+    room_title: str
+    channel_id: int
+
+    @property
+    def room_channel(self) -> RoomChannel:
+        return RoomChannel(self.room_id, self.channel_id)
+
+
+@dataclass
+class RoomLight(Light):
+    channel_id: int = 0
+
+
+@dataclass
+class ChannelLight(Light):
+    channel_type: str
+    channel_name: str
+    channel_levels: str
+
+
+@dataclass(frozen=True)
+class BridgeInfo:
+    version: str
+    buildDate: str
+    hostName: str
+    hostIP: str
+    hostMAC: str
+    hwStatus: str
+    dbVersion: str
+    requirepassword: str
+    passhash: str
+    charset: str
+
+
+# Message: Bridge to Client
+@dataclass
+class UnsupportedMessage:
+    pass
+
+
+@dataclass
+class EOFResponse:
+    pass
+
+
+@dataclass
+class LevelCacheItem:
+    active_deleted_reserved: int
+    room: int
+    channel: int
+    scene_levels: dict[int, int]  # scene, level
+
+
+# pylint: disable=E1101
+class LevelCache(dict[RoomChannel, LevelCacheItem]):
+    """dict of: RoomChannel, LevelCacheItem"""
+
+    def get_channel_level(self, room_channel: RoomChannel, scene: int) -> int:
+        level_cache_item = self.get(room_channel)
+        if level_cache_item:
+            return level_cache_item.scene_levels.get(scene, 0)
+        return 0
+
+    def get_channel_levels(self, room: int, scene: int) -> Iterable[tuple[int, int]]:
+        for lci in self.values():
+            if lci.room == room:
+                brightness = lci.scene_levels.get(scene, 0)
+                yield lci.channel, brightness
+
+
+class SceneCache(dict[int, int]):
+    """dict of: room id, scene number"""
+
+    pass
+
+
+@dataclass
+class StatusMessage:
+    room: int
+    channel: int
+
+
+@dataclass
+class SceneStatusMessage(StatusMessage):
+    scene: int
+
+
+@dataclass
+class ChannelStatusMessage(StatusMessage):
+    brightness: int
+
+
+# Message: Client to Bridge
+@dataclass
+class CommandUDP:
+    room: int
+    channel: int
+    command: CommandType
+    data: list[int]
+    message_type: MessageType = MessageType.REQUEST
+
+
+@dataclass
+class CommandHTTP:
+    room: int
+    channel: int
+
+    def as_params(self) -> dict[str, int]:
+        raise NotImplementedError()
+
+
+@dataclass
+class CommandSceneHTTP(CommandHTTP):
+    scene: int
+
+    def as_params(self) -> dict[str, int]:
+        return {
+            "room": self.room,
+            "ch": self.channel,
+            "sc": self.scene,
+        }
+
+
+@dataclass
+class CommandLevelHTTP(CommandHTTP):
+    level: int
+
+    def as_params(self) -> dict[str, int]:
+        return {
+            "room": self.room,
+            "ch": self.channel,
+            "lev": self.level,
+        }

python_rako_2025-0.0.1.dist-info/METADATA

@@ -0,0 +1,174 @@
+Metadata-Version: 2.4
+Name: python-rako-2025
+Version: 0.0.1
+Summary: Asynchronous Python client for Rako Controls Lighting
+Home-page: https://github.com/simonleigh/python-rako
+Author: Simon Leigh
+Author-email: Simon Leigh <simonleigh@users.noreply.github.com>
+Project-URL: Homepage, https://github.com/simonleigh/python-rako
+Project-URL: Repository, https://github.com/simonleigh/python-rako
+Project-URL: Issues, https://github.com/simonleigh/python-rako/issues
+Keywords: rako,controls,api,async,client
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.10.0
+Requires-Dist: asyncio-dgram>=2.2.0
+Requires-Dist: xmltodict>=0.13.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: platform
+Dynamic: requires-python
+
+# Python: Rako Controls API Client
+
+[![GitHub Release][releases-shield]][releases]
+![Project Stage][project-stage-shield]
+![Project Maintenance][maintenance-shield]
+[![License][license-shield]](LICENSE)
+
+[![Build Status][build-shield]][build]
+[![Code Coverage][codecov-shield]][codecov]
+[![Code Quality][code-quality-shield]][code-quality]
+
+[![Buy me a coffee][buymeacoffee-shield]][buymeacoffee]
+
+Asynchronous Python client for Rako Controls.
+
+## About
+
+This package allows you to control and monitor Rako Controls devices
+programmatically. It is mainly created to allow third-party programs to automate
+their behavior.
+
+## Installation
+
+```bash
+pip install python-rako
+```
+
+## Usage
+
+```python
+import asyncio
+
+
+async def main():
+    # TODO
+    pass
+
+
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main())
+```
+
+## Changelog & Releases
+
+This repository keeps a change log using [GitHub's releases][releases]
+functionality. The format of the log is based on
+[Keep a Changelog][keepchangelog].
+
+Releases are based on [Semantic Versioning][semver], and use the format
+of ``MAJOR.MINOR.PATCH``. In a nutshell, the version will be incremented
+based on the following:
+
+- ``MAJOR``: Incompatible or major changes.
+- ``MINOR``: Backwards-compatible new features and enhancements.
+- ``PATCH``: Backwards-compatible bugfixes and package updates.
+
+## Contributing
+
+This is an active open-source project. We are always open to people who want to
+use the code or contribute to it.
+
+We've set up a separate document for our
+[contribution guidelines](CONTRIBUTING.md).
+
+Thank you for being involved! :heart_eyes:
+
+## Setting up development environment
+
+In case you'd like to contribute, a `Makefile` has been included to ensure a
+quick start.
+
+```bash
+make venv
+source ./venv/bin/activate
+make dev
+```
+
+Now you can start developing, run `make` without arguments to get an overview
+of all make goals that are available (including description):
+
+```bash
+$ make
+Asynchronous Python client for Rako Controls Lighting.
+
+Usage:
+  make help                            Shows this message.
+  make dev                             Set up a development environment.
+  make lint                            Run all linters.
+  make lint-black                      Run linting using black & blacken-docs.
+  make lint-flake8                     Run linting using flake8 (pycodestyle/pydocstyle).
+  make lint-pylint                     Run linting using PyLint.
+  make lint-mypy                       Run linting using MyPy.
+  make test                            Run tests quickly with the default Python.
+  make coverage                        Check code coverage quickly with the default Python.
+  make install                         Install the package to the active Python's site-packages.
+  make clean                           Removes build, test, coverage and Python artifacts.
+  make clean-all                       Removes all venv, build, test, coverage and Python artifacts.
+  make clean-build                     Removes build artifacts.
+  make clean-pyc                       Removes Python file artifacts.
+  make clean-test                      Removes test and coverage artifacts.
+  make clean-venv                      Removes Python virtual environment artifacts.
+  make dist                            Builds source and wheel package.
+  make release                         Release build on PyP
+  make venv                            Create Python venv environment.
+```
+
+## Authors & contributors
+
+The original setup of this repository is by [Ben Marengo][marengaz].
+
+For a full list of all authors and contributors,
+check [the contributor's page][contributors].
+
+## License
+
+[License](LICENSE)
+
+[build-shield]: https://github.com/marengaz/python-rako/workflows/Continuous%20Integration/badge.svg
+[build]: https://github.com/marengaz/python-rako/actions
+[code-quality-shield]: https://img.shields.io/lgtm/grade/python/g/marengaz/python-rako.svg?logo=lgtm&logoWidth=18
+[code-quality]: https://lgtm.com/projects/g/marengaz/python-rako/context:python
+[codecov-shield]: https://codecov.io/gh/marengaz/python-rako/branch/master/graph/badge.svg
+[codecov]: https://codecov.io/gh/marengaz/python-rako
+[contributors]: https://github.com/marengaz/python-rako/graphs/contributors
+[marengaz]: https://github.com/marengaz
+[keepchangelog]: http://keepachangelog.com/en/1.0.0/
+[license-shield]: https://img.shields.io/github/license/marengaz/python-rako.svg
+[maintenance-shield]: https://img.shields.io/maintenance/yes/2021.svg
+[project-stage-shield]: https://img.shields.io/badge/project%20stage-experimental-yellow.svg
+[releases-shield]: https://img.shields.io/github/release/marengaz/python-rako.svg
+[releases]: https://github.com/marengaz/python-rako/releases
+[semver]: http://semver.org/spec/v2.0.0.html
+
+[buymeacoffee-shield]: https://www.buymeacoffee.com/assets/img/guidelines/download-assets-sm-2.svg
+[buymeacoffee]: https://www.buymeacoffee.com/marengaz
+[github-actions-shield]: https://github.com/marengaz/rakomqtt/workflows/Test%20RakoMQTT/badge.svg?branch=master
+[github-actions]: https://github.com/marengaz/rakomqtt/actions?query=workflow%3A%22Test+RakoMQTT%22+branch%3Amaster

python_rako_2025-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+python_rako/__init__.py,sha256=VC4yyKBNaSrEMEOnUFvjo5UtecfAejNfEVuv_RQcbRU,1652
+python_rako/__version__.py,sha256=HXn4hD8lyXkcmi-Ih0aF7rC1emgHC1se2G9_NxE9GpY,54
+python_rako/bridge.py,sha256=u2noCdFzlALB4MR_xxia-iUY8g5lXv7xsPKBOYbcG8c,9779
+python_rako/const.py,sha256=PO-MEmq8Q6G_Mhv-8UAcdj-LM0dXdFZdR14Qqd88DQg,1197
+python_rako/exceptions.py,sha256=VfpEV7yHM3EWA3Z9hSMr2LdhNnxs3NdjoN0OxHRteJ0,43
+python_rako/helpers.py,sha256=LTKvOo9gVU11Kym2G5j35si9yURb5AFMIweZHbHqzt4,5599
+python_rako/model.py,sha256=EnZbJmJeyzkOtqkpEI5eOZzKFSxvjcycMib6WtQGmX4,2772
+python_rako/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_rako_2025-0.0.1.dist-info/licenses/LICENSE,sha256=BU3YBlT_uVhhi08vzf1BVhardfVKviv-7Z-avAvSfx0,1068
+python_rako_2025-0.0.1.dist-info/METADATA,sha256=5xG4gYzD-00UMHnXt9KypHdSsh6xQ7Qp4IXTEuJ5huM,6587
+python_rako_2025-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+python_rako_2025-0.0.1.dist-info/top_level.txt,sha256=H8L2l0YJulkcvNu1s0hPBHlMohbeOpsGo8MD6sZo764,12
+python_rako_2025-0.0.1.dist-info/RECORD,,

python_rako_2025-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_rako_2025-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Ben Marengo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python_rako_2025-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+python_rako