pyplejd 0.1__tar.gz

pyplejd-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Thomas Lovén
+
+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.

pyplejd-0.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pyplejd
+Version: 0.1
+Summary: A python library for communicating with Plejd devices via bluetooth
+Home-page: https://github.com/thomasloven/pyplejd
+Download-URL: https://github.com/thomasloven/pyplejd/archive/v0.1.tar.gz
+Author: Thomas Lovén
+Author-email: thomasloven@gmail.com
+License: MIT
+Keywords: plejd,bluetooth,homeassistant
+Requires-Python: >=3.10
+License-File: LICENSE

pyplejd-0.1/pyplejd/__init__.py

@@ -0,0 +1,90 @@
+import logging
+from datetime import timedelta
+
+from bleak_retry_connector import close_stale_connections
+
+from .mesh import PlejdMesh
+from .api import get_cryptokey, get_devices, get_site_data, get_scenes
+from .plejd_device import PlejdDevice, PlejdScene
+
+from .const import PLEJD_SERVICE, LIGHT, SWITCH
+
+_LOGGER = logging.getLogger(__name__)
+
+class PlejdManager:
+
+    def __init__(self, credentials):
+        self.credentials = credentials
+        self.mesh = PlejdMesh()
+        self.mesh.statecallback = self._update_device
+        self.devices = { }
+        self.scenes = []
+
+    def add_mesh_device(self, device, rssi):
+        _LOGGER.debug("Adding plejd %s", device)
+        # for d in self.devices.values():
+        #     addr = device.address.replace(":","").replace("-","").upper()
+        #     if d.BLE_address.upper() == addr or addr in device.name:
+        return self.mesh.add_mesh_node(device, rssi)
+        # _LOGGER.debug("Device was not expected in current mesh")
+
+    async def close_stale(self, device):
+        _LOGGER.debug("Closing stale connections for %s", device)
+        await close_stale_connections(device)
+
+    @property
+    def connected(self):
+        return self.mesh is not None and self.mesh.connected
+
+    async def get_site_data(self):
+        return await get_site_data(**self.credentials)
+
+    async def get_devices(self):
+        devices = await get_devices(**self.credentials)
+        self.devices = {k: PlejdDevice(self, **v) for (k,v) in devices.items()}
+        _LOGGER.debug("Devices")
+        _LOGGER.debug(self.devices)
+        return self.devices
+
+    async def get_scenes(self):
+        scenes = await get_scenes(**self.credentials)
+        self.scenes = [PlejdScene(self, **s) for s in scenes]
+        _LOGGER.debug("Scenes")
+        _LOGGER.debug(self.scenes)
+        return self.scenes
+
+    async def _update_device(self, deviceState):
+        address = deviceState["address"]
+        if address in self.devices:
+            await self.devices[address].new_state(deviceState.get("state"), deviceState.get("dim", 0))
+
+    @property
+    def keepalive_interval(self):
+        if self.mesh.pollonWrite:
+            return timedelta(seconds=10)
+        else:
+            return timedelta(minutes=10)
+
+    async def keepalive(self):
+        if self.mesh.crypto_key is None:
+            self.mesh.set_crypto_key(await get_cryptokey(**self.credentials))
+        if not self.mesh.connected:
+            if not await self.mesh.connect():
+                return False
+        retval = await self.mesh.ping()
+        if retval and self.mesh.pollonWrite:
+            await self.mesh.poll()
+        return retval
+
+    async def disconnect(self):
+        _LOGGER.debug("DISCONNECT")
+        await self.mesh.disconnect()
+
+    async def poll(self):
+        await self.mesh.poll()
+
+    async def ping(self):
+        retval = await self.mesh.ping()
+        if self.mesh.pollonWrite:
+            await self.poll()
+        return retval

pyplejd-0.1/pyplejd/api.py

@@ -0,0 +1,135 @@
+from aiohttp import ClientSession
+import json
+import logging
+
+_LOGGER = logging.getLogger(__name__)
+
+API_APP_ID = 'zHtVqXt8k4yFyk2QGmgp48D9xZr2G94xWYnF4dak'
+API_BASE_URL = 'https://cloud.plejd.com'
+API_LOGIN_URL = '/parse/login'
+API_SITE_LIST_URL = '/parse/functions/getSiteList'
+API_SITE_DETAILS_URL = '/parse/functions/getSiteById'
+
+
+headers = {
+        "X-Parse-Application-Id": API_APP_ID,
+        "Content-Type": "application/json",
+    }
+
+async def _login(session, username, password):
+    body = {
+        "username": username,
+        "password": password,
+    }
+
+    async with session.post(API_LOGIN_URL, json=body, raise_for_status=True) as resp:
+        data = await resp.json()
+        return data.get("sessionToken")
+
+async def _get_sites(session):
+    resp = await session.post(API_SITE_LIST_URL, raise_for_status=True)
+    return await resp.json()
+
+async def _get_site_details(session, siteId):
+    async with session.post(
+                API_SITE_DETAILS_URL,
+                params={"siteId": siteId},
+                raise_for_status=True
+                ) as resp:
+        data = await resp.json()
+        data = data.get("result")
+        data = data[0]
+        # with open("site_details.json", "w") as fp:
+        #     fp.write(json.dumps(data))
+        return data
+
+site_data = {}
+async def get_site_data(username, password, siteId, **_):
+    global site_data
+    if site_data.get(siteId) is not None:
+        return site_data.get(siteId)
+    async with ClientSession(base_url=API_BASE_URL, headers=headers) as session:
+        session_token = await _login(session, username, password)
+        session.headers["X-Parse-Session-Token"] = session_token
+        details = await _get_site_details(session, siteId)
+        site_data[siteId] = details
+        return details
+
+async def get_sites(username, password, **_):
+    async with ClientSession(base_url=API_BASE_URL, headers=headers) as session:
+        session_token = await _login(session, username, password)
+        session.headers["X-Parse-Session-Token"] = session_token
+        sites = await _get_sites(session)
+        return sites["result"]
+
+
+async def get_cryptokey(**credentials):
+    sitedata = await get_site_data(**credentials)
+    return sitedata["plejdMesh"]["cryptoKey"]
+
+async def get_devices(**credentials):
+    site_data = await get_site_data(**credentials)
+
+    retval = {}
+    for device in site_data["devices"]:
+        BLE_address = device["deviceId"]
+
+        address = site_data["deviceAddress"][BLE_address]
+        dimmable = None
+
+        settings = next((s for s in site_data["outputSettings"] 
+            if s["deviceParseId"] == device["objectId"]), None)
+
+        if settings is not None and "output" in settings:
+            outputs = site_data["outputAddress"][BLE_address]
+            address = outputs[str(settings["output"])]
+
+        if settings is not None:
+            if settings.get("dimCurve") is not None:
+                if settings.get("dimCurve") in ["nonDimmable", "RelayNormal"]:
+                    dimmable = False
+                else:
+                    dimmable = True
+            if settings.get("predefinedLoad",{}).get("loadType") == "No load":
+                continue
+
+        plejdDevice = next((s for s in site_data["plejdDevices"]
+                if s["deviceId"] == BLE_address), None)
+        room = next((r for r in site_data["rooms"] if r["roomId"] == device["roomId"]), {})
+
+        retval[address] = {
+            "address": address,
+            "BLE_address": BLE_address,
+            "data": {
+                "name": device["title"],
+                "hardwareId": plejdDevice["hardwareId"],
+                "dimmable": dimmable,
+                "outputType": convertType(device.get("outputType")),
+                "room": room.get("title"),
+                "firmware": plejdDevice["firmware"]["version"],
+            }
+        }
+
+    return retval
+
+def convertType(outputType):
+    if (outputType == "LIGHT"):
+        return "light"
+    elif (outputType == "RELAY"):
+        return "switch"
+    return None
+
+async def get_scenes(**credentials):
+    site_data = await get_site_data(**credentials)
+    retval = []
+    for scene in site_data["scenes"]:
+        if scene["hiddenFromSceneList"]: continue
+        sceneId = scene["sceneId"]
+        index = site_data["sceneIndex"].get(sceneId)
+
+        retval.append({
+            "index": index,
+            "title": scene["title"],
+        })
+        
+    return retval

pyplejd-0.1/pyplejd/ble_device.py

@@ -0,0 +1,21 @@
+"""
+Wrapper class for BLEDevice with RSSI from AdvertisementData.
+"""
+
+from bleak.backends.device import BLEDevice
+
+class BLEDeviceWithRssi:
+    def __init__(self, device: BLEDevice, rssi: int):
+        self.device = device
+        self.rssi = rssi
+
+    def __str__(self):
+        return self.device.__str__()
+
+    def __repr__(self):
+        return self.device.__repr__()
+
+    def __eq__(self, other):
+        if isinstance(other, BLEDeviceWithRssi):
+            return self.device == other.device
+        return False

pyplejd-0.1/pyplejd/const.py

@@ -0,0 +1,12 @@
+BLE_UUID_SUFFIX = '6085-4726-be45-040c957391b5'
+PLEJD_SERVICE = f'31ba0001-{BLE_UUID_SUFFIX}'
+PLEJD_LIGHTLEVEL = f'31ba0003-{BLE_UUID_SUFFIX}'
+PLEJD_DATA = f'31ba0004-{BLE_UUID_SUFFIX}'
+PLEJD_LASTDATA = f'31ba0005-{BLE_UUID_SUFFIX}'
+PLEJD_AUTH = f'31ba0009-{BLE_UUID_SUFFIX}'
+PLEJD_PING = f'31ba000a-{BLE_UUID_SUFFIX}'
+
+LIGHT = "light"
+SENSOR = "sensor"
+SWITCH = "switch"
+UNKNOWN = "unknown"

pyplejd-0.1/pyplejd/crypto.py

@@ -0,0 +1,29 @@
+import hashlib
+import struct
+
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.backends import default_backend
+
+def encrypt_decrypt(key, addr, data):
+    buf = addr + addr + addr[:4]
+
+    ct = Cipher(
+            algorithms.AES(bytearray(key)),
+            modes.ECB(),
+            backend=default_backend()
+        )
+    ct = ct.encryptor()
+    ct = ct.update(buf)
+
+    output = b""
+    for i,d in enumerate(data):
+        output += struct.pack("B", d^ct[i%16])
+    return output
+
+def auth_response(key, challenge):
+    k = int.from_bytes(key, "big")
+    c = int.from_bytes(challenge, "big")
+    intermediate = hashlib.sha256((k^c).to_bytes(16, "big")).digest()
+    part1 = intermediate[:16]
+    part2 = intermediate[16:]
+    return bytearray([(a^b) for (a,b) in zip(part1, part2)])

pyplejd-0.1/pyplejd/mesh.py

@@ -0,0 +1,255 @@
+import asyncio
+import binascii
+import logging
+import os
+import struct
+from datetime import datetime
+from bleak import BleakClient, BleakError
+from bleak_retry_connector import establish_connection
+from bleak.backends.device import BLEDevice
+
+from .ble_device import BLEDeviceWithRssi
+from .const import PLEJD_AUTH, PLEJD_LASTDATA, PLEJD_LIGHTLEVEL, PLEJD_PING, PLEJD_DATA
+from .crypto import auth_response, encrypt_decrypt
+
+_LOGGER = logging.getLogger(__name__)
+
+class PlejdMesh():
+
+    def __init__(self):
+        self._connected = False
+        self.client = None
+        self.connected_node = None
+        self.crypto_key = None
+        self.mesh_nodes = []
+
+        self.pollonWrite = True # TODO: Deprecate this
+        self.statecallback = None
+        self.scenecallback = None
+        self.buttoncallback = None
+
+        self._ble_lock = asyncio.Lock()
+
+    def add_mesh_node(self, ble_device: BLEDevice, rssi: int):
+        device = BLEDeviceWithRssi(ble_device, rssi)
+        if device not in self.mesh_nodes:
+            self.mesh_nodes.append(device)
+        else:
+            _LOGGER.debug("Plejd already added")
+
+    def set_crypto_key(self, key):
+        self.crypto_key = binascii.a2b_hex(key.replace("-", ""))
+
+    @property
+    def connected(self):
+        if self._connected and self.client and self.client.is_connected:
+            return True
+        return False
+
+    async def disconnect(self):
+        if self.connected and self.client:
+            try:
+                await self.client.stop_notify(PLEJD_LASTDATA)
+                await self.client.stop_notify(PLEJD_LIGHTLEVEL)
+                await self.client.disconnect()
+            except BleakError:
+                pass
+            self._connected = False
+            self.client = None
+    
+    async def connect(self, disconnect_callback=None, key=None):
+        await self.disconnect()
+        _LOGGER.debug("Trying to connect to mesh")
+
+        def _disconnect(arg):
+            if not self.connected: return
+            _LOGGER.debug("_disconnect %s", arg)
+            self.client = None
+            self._connected = False
+            if disconnect_callback:
+                disconnect_callback()
+
+        self.mesh_nodes.sort(key = lambda a: a.rssi, reverse = True)
+        for plejd in self.mesh_nodes:
+            try:
+                _LOGGER.debug("Connecting to %s", plejd)
+                client = await establish_connection(BleakClient, plejd.device, "plejd", _disconnect)
+                address = plejd.device.address
+                self._connected = True
+                self.client = client
+                _LOGGER.debug("Connected to Plejd mesh")
+                if not await self._authenticate():
+                    await self.client.disconnect()
+                    self._connected = False
+                    continue
+                break
+            except (BleakError, asyncio.TimeoutError) as e:
+                _LOGGER.warning("Error connecting to Plejd device: %s", str(e))
+        else:
+            if len(self.mesh_nodes) == 0:
+                _LOGGER.debug("Failed to connect to plejd mesh - no devices discovered")
+            else:
+                _LOGGER.warning("Failed to connect to plejd mesh - %s", self.mesh_nodes)
+            return False
+
+        self.connected_node = binascii.a2b_hex(address.replace(":", "").replace("-", ""))[::-1]
+
+        async def _lastdata(_, lastdata):
+            self.pollonWrite = False
+            data = encrypt_decrypt(self.crypto_key, self.connected_node, lastdata)
+            _LOGGER.debug("Received LastData %s", data.hex())
+            deviceState = decode_state(data)
+            _LOGGER.debug("Decoded LastData %s", deviceState)
+            if deviceState is None:
+                return
+            if self.statecallback and "state" in deviceState:
+                await self.statecallback(deviceState)
+            if self.scenecallback and "scene" in deviceState:
+                await self.scenecallback(deviceState)
+            if self.buttoncallback and "button" in deviceState:
+                await self.buttoncallback(deviceState)
+
+        async def _lightlevel(_, lightlevel):
+            _LOGGER.debug("Received LightLevel %s", lightlevel.hex())
+            for i in range(0, len(lightlevel), 10):
+                ll = lightlevel[i:i+10]
+                deviceState = {
+                    "address": int(ll[0]),
+                    "state": bool(ll[1]),
+                    "dim": int.from_bytes(ll[5:7], "little"),
+                }
+                _LOGGER.debug("Decoded LightLevel %s", deviceState)
+                if self.statecallback and deviceState is not None:
+                    await self.statecallback(deviceState)
+
+        await client.start_notify(PLEJD_LASTDATA, _lastdata)
+        await client.start_notify(PLEJD_LIGHTLEVEL, _lightlevel)
+        
+        await self.poll()
+
+        return True
+
+    async def write(self, payload):
+        try:
+            # TODO:
+            async with self._ble_lock:
+                _LOGGER.debug("Writing data to Plejd mesh CT: %s", payload.hex())
+                data = encrypt_decrypt(self.crypto_key, self.connected_node, payload)
+                await self.client.write_gatt_char(PLEJD_DATA, data, response=True)
+        except (BleakError, asyncio.TimeoutError) as e:
+            _LOGGER.warning("Plejd mesh write command failed: %s", str(e))
+            return False
+        return True
+
+    async def set_state(self, address, state, dim=0):
+        payload = encode_state(address, state, dim)
+        retval = await self.write(payload)
+        if self.pollonWrite:
+            await self.poll()
+        return retval
+
+    async def activate_scene(self, index):
+        payload = binascii.a2b_hex(f"0201100021{index:02x}")
+        retval = await self.write(payload)
+        if self.pollonWrite:
+            await self.poll()
+        return retval
+
+    async def ping(self):
+        async with self._ble_lock:
+            return await self._ping()
+                
+    async def _ping(self):
+        if self.client is None:
+            return False
+        try:
+            ping = bytearray(os.urandom(1))
+            _LOGGER.debug("Ping(%s)", int.from_bytes(ping, "little"))
+            await self.client.write_gatt_char(PLEJD_PING, ping, response=True)
+            pong = await self.client.read_gatt_char(PLEJD_PING)
+            _LOGGER.debug("Pong(%s)", int.from_bytes(pong, "little"))
+            if (ping[0] + 1) & 0xFF == pong[0]:
+                return True
+        except (BleakError, asyncio.TimeoutError) as e:
+            _LOGGER.warning("Plejd mesh keepalive signal failed: %s", str(e))
+        self.pollonWrite = True
+        return False
+
+    async def poll(self):
+        if self.client is None:
+            return
+        _LOGGER.debug("Polling Plejd mesh for current state")
+        async with self._ble_lock:
+            await self.client.write_gatt_char(PLEJD_LIGHTLEVEL, b"\x01", response=True)
+
+    async def _authenticate(self):
+        if self.client is None:
+            return False
+        try:
+            async with self._ble_lock:
+                _LOGGER.debug("Authenticating to plejd mesh")
+                await self.client.write_gatt_char(PLEJD_AUTH, b"\0x00", response=True)
+                challenge = await self.client.read_gatt_char(PLEJD_AUTH)
+                response = auth_response(self.crypto_key, challenge)
+                await self.client.write_gatt_char(PLEJD_AUTH, response, response=True)
+                if not await self._ping():
+                    _LOGGER.debug("Authenticion failed")
+                    return False
+                _LOGGER.debug("Authenticated successfully")
+                return True
+        except (BleakError, asyncio.TimeoutError) as e:
+            _LOGGER.warning("Plejd authentication failed: %s", str(e))
+        return False
+
+
+def decode_state(data):
+    address = int(data[0])
+    cmdtype = data[1:3]
+    if not cmdtype == b"\x01\x10":
+        _LOGGER.debug("Got non-command data: %s", cmdtype)
+        return None
+    cmd = data[3:5]
+
+    # if address == 0:
+    #     # Broadcast
+    #     pass
+    if address == 1 and cmd == b"\x00\x1b":
+        _LOGGER.debug("Got time data?")
+        ts = struct.unpack_from("<I", data, 5)[0]
+        dt = datetime.fromtimestamp(ts)
+        _LOGGER.debug("Timestamp: %s (%s)", ts, dt)
+        return None
+    # if address == 2:
+    #     # Scene update?
+    #     pass
+
+    retval = {"address": address}
+
+    if cmd == b"\x00\xc8" or cmd == b"\x00\x98":
+        retval["state"] = bool(data[5])
+        retval["dim"] = int.from_bytes(data[6:8], "little")        
+    elif cmd == b"\x00\x97":
+        retval["state"] = bool(data[5])
+    elif cmd == b"\x00\x16":
+        retval["address"] = int(data[5])
+        retval["button"] = int(data[6])
+        _LOGGER.info("Button pressed: %s", retval)
+    elif cmd == b"\x00\x21":
+        del retval["address"]
+        retval["scene"] = int(data[5])
+        _LOGGER.info("Scene triggered: %s", retval)
+    else:
+        _LOGGER.debug("Unknown command %s", cmd)
+        return None
+
+    return retval
+
+
+def encode_state(address, state, dim):
+    if state:
+        if dim is None:
+            return binascii.a2b_hex(f"{address:02x}0110009701")
+        brightness = dim << 8 | dim
+        return binascii.a2b_hex(f"{address:02x}0110009801{brightness:04x}")
+    else:
+        return binascii.a2b_hex(f"{address:02x}0110009700")

pyplejd-0.1/pyplejd/plejd_device.py

@@ -0,0 +1,135 @@
+
+from builtins import property
+from collections import namedtuple
+import logging
+from .const import LIGHT, SENSOR, SWITCH, UNKNOWN
+
+_LOGGER = logging.getLogger(__name__)
+
+Device = namedtuple("Device", ["model", "type", "dimmable"])
+
+HARDWARE_TYPES = {
+    "0": Device("-unknown-", UNKNOWN, False),
+    "1": Device("DIM-01", LIGHT, True),
+    "2": Device("DIM-02", LIGHT, True),
+    "3": Device("CTR-01", LIGHT, False),
+    "4": Device("GWY-01", SENSOR, False),
+    "5": Device("LED-10", LIGHT, True),
+    "6": Device("WPH-01", SWITCH, False),
+    "7": Device("REL-01", SWITCH, False),
+    "8": Device("SPR-01", SWITCH, False),
+    "10": Device("WRT-01", SWITCH, False),
+    "11": Device("DIM-01-2P", LIGHT, True),
+    "13": Device("Generic", LIGHT, False),
+    "14": Device("DIM-01-LC", LIGHT, True),
+    "15": Device("DIM-02-LC", LIGHT, True),
+    "17": Device("REL-01-2P", SWITCH, False),
+    "18": Device("REL-02", SWITCH, False),
+    "20": Device("SPR-01", SWITCH, False),
+    "36": Device("LED-75", LIGHT, True),
+}
+
+class PlejdDevice:
+
+    def __init__(self, manager, address, BLE_address, data):
+        self.manager = manager
+        self.address = address
+        self._BLE_address = BLE_address
+        self.data = data #{name, hardwareId, dimmable, outputType, room, firmware}
+
+        self.updateCallback = None
+
+        self._state = None
+        self._dim = None
+
+    def __repr__(self):
+        return f"<PlejdDevice(<manager>, {self.address}, {self.BLE_address}, {self.data}>"
+
+    @property
+    def available(self):
+        return self.manager.connected and self._state is not None
+
+    @property
+    def state(self):
+        return self._state if self.available else False
+
+    @property
+    def dim(self):
+        return self._dim/256 if self._dim else 0
+
+    @property
+    def BLE_address(self):
+        return self._BLE_address
+
+    @property
+    def name(self):
+        return self.data["name"]
+    @property
+    def room(self):
+        return self.data["room"]
+    @property
+    def firmware(self):
+        return self.data["firmware"]
+    @property
+    def hardwareId(self):
+        return self.data["hardwareId"]
+
+    @property
+    def type(self):
+        return self.data.get("outputType") or self.hardware_data.type
+    @property
+    def model(self):
+        return self.hardware_data.model
+    @property
+    def dimmable(self):
+        if self.data["dimmable"] is not None:
+            return self.data["dimmable"]
+        return self.hardware_data.dimmable
+    
+    @property
+    def hardware_data(self):
+        deviceType = HARDWARE_TYPES.get(self.data["hardwareId"], HARDWARE_TYPES["0"])
+        return deviceType
+
+    async def new_state(self, state, dim):
+        update = False
+        if state != self._state:
+            update = True
+            self._state = state
+        if dim != self._dim:
+            update = True
+            self._dim = dim
+        if update:
+            if self.updateCallback:
+                self.updateCallback({"state": self._state, "dim": self._dim})
+
+    async def turn_on(self, dim=0):
+        await self.manager.mesh.set_state(self.address, True, dim)
+
+    async def turn_off(self):
+        await self.manager.mesh.set_state(self.address, False)
+
+class PlejdScene:
+
+    def __init__(self, manager, index, title):
+        self._manager = manager
+        self._index = index
+        self._title = title
+
+    def __repr__(self):
+        return f"<PlejdScene(<manager>, {self._index}, '{self._title}'>"
+
+    @property
+    def name(self):
+        return self._title
+
+    @property
+    def index(self):
+        return self._index
+
+    @property
+    def available(self):
+        return self._manager.connected
+
+    async def activate(self):
+        await self._manager.mesh.activate_scene(self._index)

pyplejd-0.1/pyplejd.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: pyplejd
+Version: 0.1
+Summary: A python library for communicating with Plejd devices via bluetooth
+Home-page: https://github.com/thomasloven/pyplejd
+Download-URL: https://github.com/thomasloven/pyplejd/archive/v0.1.tar.gz
+Author: Thomas Lovén
+Author-email: thomasloven@gmail.com
+License: MIT
+Keywords: plejd,bluetooth,homeassistant
+Requires-Python: >=3.10
+License-File: LICENSE

pyplejd-0.1/pyplejd.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+setup.cfg
+setup.py
+pyplejd/__init__.py
+pyplejd/api.py
+pyplejd/ble_device.py
+pyplejd/const.py
+pyplejd/crypto.py
+pyplejd/mesh.py
+pyplejd/plejd_device.py
+pyplejd.egg-info/PKG-INFO
+pyplejd.egg-info/SOURCES.txt
+pyplejd.egg-info/dependency_links.txt
+pyplejd.egg-info/requires.txt
+pyplejd.egg-info/top_level.txt

pyplejd-0.1/pyplejd.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyplejd-0.1/pyplejd.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp

pyplejd-0.1/pyplejd.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyplejd

pyplejd-0.1/setup.cfg

@@ -0,0 +1,7 @@
+[metadata]
+description-file = README.md
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyplejd-0.1/setup.py

@@ -0,0 +1,20 @@
+from setuptools import find_packages, setup
+
+MIN_PY_VERSION = "3.10"
+PACKAGES = find_packages()
+VERSION = "0.1"
+
+setup(
+    name="pyplejd",
+    packages=PACKAGES,
+    version=VERSION,
+    description="A python library for communicating with Plejd devices via bluetooth",
+    author="Thomas Lovén",
+    author_email="thomasloven@gmail.com",
+    license="MIT",
+    url="https://github.com/thomasloven/pyplejd",
+    download_url=f"https://github.com/thomasloven/pyplejd/archive/v{VERSION}.tar.gz",
+    install_requires=["aiohttp"],
+    keywords=["plejd", "bluetooth", "homeassistant"],
+    python_requires=f">={MIN_PY_VERSION}",
+)