yeelight-lan 0.2.2__tar.gz

yeelight_lan-0.2.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nowplaylab (tryshyzov and Claude)
+
+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.

yeelight_lan-0.2.2/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: yeelight-lan
+Version: 0.2.2
+Summary: Yeelight over the home network: discovery, commands and music mode, plus a strip emulator
+Author: nowplaylab
+License: MIT
+Project-URL: Homepage, https://github.com/nowplaylab/yeelight-lan
+Project-URL: Issues, https://github.com/nowplaylab/yeelight-lan/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8
+Dynamic: license-file
+
+# yeelight-lan
+
+**English** | [Русский](https://github.com/nowplaylab/yeelight-lan/blob/main/README.ru.md)
+
+Control Yeelight lamps and light strips over your home network from Python: discovery, colour, brightness and **music mode** for flashing to the beat. No cloud, no account. Comes with a **strip emulator**, so you can build and test without the hardware.
+
+Made by [nowplaylab](https://github.com/nowplaylab) for [NowPlaying](https://github.com/nowplaylab/nowplaying-display), where a strip follows the album cover and pulses with the bass.
+
+## Install
+
+```
+pip install git+https://github.com/nowplaylab/yeelight-lan@v0.2.2
+```
+
+Python 3.9+. Turn on **LAN Control** for the device in the Yeelight app first.
+
+## Use
+
+```python
+import asyncio
+import yeelight_lan
+
+devices = yeelight_lan.discover()            # [Device(id, ip, name, model, ...)]
+bulb = yeelight_lan.Bulb(devices[0].ip)
+
+async def main():
+    await bulb.set_rgb(0xff6600)             # smooth change, 500 ms
+    await bulb.set_bright(70)
+    print(await bulb.get_props('power', 'bright', 'rgb'))
+
+    # music mode: the device connects to you and takes commands with no reply and no rate limit
+    async with bulb.music() as m:
+        for level in (20, 100, 40, 100):
+            m.send('set_bright', [level, 'sudden', 30])
+            await asyncio.sleep(0.25)
+
+asyncio.run(main())
+```
+
+Plain commands are limited by the device to **60 per minute per connection**; `Bulb` opens a short connection per command, which also survives Wi-Fi drops and device restarts. For anything faster, use `MusicMode`.
+
+## Emulator
+
+```
+python -m yeelight_lan.emulator
+```
+
+Pretends to be a Yeelight strip with LAN control on: answers discovery, takes commands on port 55443, enforces the 60/min limit and supports music mode. Open `http://<computer address>:47850` on any device at home to see the strip glow with whatever it was sent, plus a log of commands.
+
+From tests:
+
+```python
+strip = await yeelight_lan.emulator.start(port=0, web=None, ssdp=False)
+bulb = yeelight_lan.Bulb('127.0.0.1', strip.port)
+```
+
+## Licence
+
+MIT.

yeelight_lan-0.2.2/README.md

@@ -0,0 +1,59 @@
+# yeelight-lan
+
+**English** | [Русский](https://github.com/nowplaylab/yeelight-lan/blob/main/README.ru.md)
+
+Control Yeelight lamps and light strips over your home network from Python: discovery, colour, brightness and **music mode** for flashing to the beat. No cloud, no account. Comes with a **strip emulator**, so you can build and test without the hardware.
+
+Made by [nowplaylab](https://github.com/nowplaylab) for [NowPlaying](https://github.com/nowplaylab/nowplaying-display), where a strip follows the album cover and pulses with the bass.
+
+## Install
+
+```
+pip install git+https://github.com/nowplaylab/yeelight-lan@v0.2.2
+```
+
+Python 3.9+. Turn on **LAN Control** for the device in the Yeelight app first.
+
+## Use
+
+```python
+import asyncio
+import yeelight_lan
+
+devices = yeelight_lan.discover()            # [Device(id, ip, name, model, ...)]
+bulb = yeelight_lan.Bulb(devices[0].ip)
+
+async def main():
+    await bulb.set_rgb(0xff6600)             # smooth change, 500 ms
+    await bulb.set_bright(70)
+    print(await bulb.get_props('power', 'bright', 'rgb'))
+
+    # music mode: the device connects to you and takes commands with no reply and no rate limit
+    async with bulb.music() as m:
+        for level in (20, 100, 40, 100):
+            m.send('set_bright', [level, 'sudden', 30])
+            await asyncio.sleep(0.25)
+
+asyncio.run(main())
+```
+
+Plain commands are limited by the device to **60 per minute per connection**; `Bulb` opens a short connection per command, which also survives Wi-Fi drops and device restarts. For anything faster, use `MusicMode`.
+
+## Emulator
+
+```
+python -m yeelight_lan.emulator
+```
+
+Pretends to be a Yeelight strip with LAN control on: answers discovery, takes commands on port 55443, enforces the 60/min limit and supports music mode. Open `http://<computer address>:47850` on any device at home to see the strip glow with whatever it was sent, plus a log of commands.
+
+From tests:
+
+```python
+strip = await yeelight_lan.emulator.start(port=0, web=None, ssdp=False)
+bulb = yeelight_lan.Bulb('127.0.0.1', strip.port)
+```
+
+## Licence
+
+MIT.

yeelight_lan-0.2.2/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yeelight-lan"
+version = "0.2.2"
+description = "Yeelight over the home network: discovery, commands and music mode, plus a strip emulator"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+dependencies = ["aiohttp>=3.8"]
+authors = [{name = "nowplaylab"}]
+classifiers = ["Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Framework :: AsyncIO"]
+
+[project.urls]
+Homepage = "https://github.com/nowplaylab/yeelight-lan"
+Issues = "https://github.com/nowplaylab/yeelight-lan/issues"
+
+[tool.setuptools]
+packages = ["yeelight_lan"]

yeelight_lan-0.2.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yeelight_lan-0.2.2/tests/test_yeelight.py

@@ -0,0 +1,93 @@
+"""Проверки на встроенном эмуляторе: команды, лимит частоты, музыкальный режим, поиск."""
+import asyncio
+import time
+import unittest
+
+import yeelight_lan
+from yeelight_lan import emulator
+
+
+class YeelightTest(unittest.IsolatedAsyncioTestCase):
+    async def asyncSetUp(self):
+        self.strip = await emulator.start(port=0, web=None, ssdp=False, host='127.0.0.1')
+        self.bulb = yeelight_lan.Bulb('127.0.0.1', self.strip.port)
+
+    async def asyncTearDown(self):
+        self.strip.server.close()
+
+    async def test_commands(self):
+        await self.bulb.set_rgb(0x123456)
+        await self.bulb.set_bright(42)
+        props = await self.bulb.get_props('rgb', 'bright', 'color_mode', 'power')
+        self.assertEqual(props, {'rgb': str(0x123456), 'bright': '42', 'color_mode': '1', 'power': 'on'})
+        await self.bulb.set_ct(2700)
+        self.assertEqual((await self.bulb.get_props('color_mode', 'ct')), {'color_mode': '2', 'ct': '2700'})
+        await self.bulb.set_power(False)
+        self.assertEqual(self.strip.power, 'off')
+
+    async def test_unknown_method(self):
+        with self.assertRaises(yeelight_lan.YeelightError):
+            await self.bulb.command('no_such_method', [])
+
+    async def test_no_device(self):
+        with self.assertRaises(yeelight_lan.YeelightError):
+            await yeelight_lan.Bulb('127.0.0.1', 1, timeout=1).set_rgb(1)
+
+    async def test_quota(self):
+        # лимит — 60 команд в минуту на одно соединение: шлём 61 по одному соединению
+        reader, writer = await asyncio.open_connection('127.0.0.1', self.strip.port)
+        for i in range(61):
+            writer.write(b'{"id":%d,"method":"set_bright","params":[50,"sudden",0]}\r\n' % (i + 1))
+        await writer.drain()
+        errors = 0
+        for _ in range(61 * 2):
+            line = await asyncio.wait_for(reader.readline(), 3)
+            errors += b'quota' in line
+            if errors:
+                break
+        writer.close()
+        self.assertEqual(errors, 1)
+
+    async def test_music_mode(self):
+        async with self.bulb.music(local_ip='127.0.0.1') as m:
+            self.assertTrue(m.alive)
+            for b in (10, 90, 30):
+                self.assertTrue(m.send('set_bright', [b, 'sudden', 0]))
+            await asyncio.sleep(0.3)
+        self.assertEqual(self.strip.bright, 30)
+        self.assertEqual(self.strip.music_cmds, 3)
+
+    async def test_music_mode_is_immediate(self):
+        # мелкие команды подряд не должны копиться в пачки: каждая доходит почти сразу
+        async with self.bulb.music(local_ip='127.0.0.1') as m:
+            await asyncio.sleep(0.1)
+            delays = []
+            for i in range(20):
+                n = len(self.strip.music_times)
+                sent = time.perf_counter()
+                m.send('set_bright', [10 + i, 'sudden', 0])
+                while len(self.strip.music_times) == n and time.perf_counter() - sent < 1:
+                    await asyncio.sleep(0.001)
+                delays.append(self.strip.music_times[-1] - sent)
+                await asyncio.sleep(0.01)
+        self.assertLess(max(delays), 0.05, delays)
+
+    async def test_discover(self):
+        strip = await emulator.start(name='Поиск', port=0, web=None, ssdp=True)
+        await asyncio.sleep(0.2)
+        try:
+            found = await asyncio.get_running_loop().run_in_executor(
+                None, lambda: yeelight_lan.discover(1.0, target=('127.0.0.1', 1982)))
+        finally:
+            strip.server.close()
+            if strip.ssdp:
+                strip.ssdp.close()
+        mine = [d for d in found if d.id == strip.id]
+        if not mine:
+            self.skipTest('порт поиска 1982 занят (например, уже запущен эмулятор)')
+        d = mine[0]
+        self.assertEqual((d.name, d.port, d.color, d.music), ('Поиск', strip.port, True, True))
+
+
+if __name__ == '__main__':
+    unittest.main()

yeelight_lan-0.2.2/yeelight_lan/__init__.py

@@ -0,0 +1,272 @@
+"""Yeelight по домашней сети: поиск, команды и музыкальный режим (без облака и аккаунта).
+
+На ленте или лампе в приложении Yeelight должно быть включено «Управление по локальной сети»
+(LAN control). Протокол — Yeelight WiFi Light Inter-Operation Specification:
+поиск SSDP на 239.255.255.250:1982, команды — строки JSON по TCP 55443.
+
+    import asyncio, yeelight_lan
+    devices = yeelight_lan.discover()
+    bulb = yeelight_lan.Bulb(devices[0].ip)
+    asyncio.run(bulb.set_rgb(0xff6600))
+
+Обычные команды устройство принимает не чаще 60 в минуту на соединение. Для быстрых изменений
+(мигание в такт) есть музыкальный режим — MusicMode: устройство само подключается к программе
+и принимает команды без ответа и без ограничения частоты.
+
+Эмулятор для проверки без железа: python -m yeelight_lan.emulator
+"""
+import asyncio
+import json
+import socket
+import time
+from dataclasses import dataclass, field
+
+__version__ = '0.2.2'
+__all__ = ['Device', 'discover', 'local_ips', 'Bulb', 'MusicMode', 'YeelightError']
+
+SSDP = ('239.255.255.250', 1982)
+SEARCH = ('M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1982\r\nMAN: "ssdp:discover"\r\n'
+          'ST: wifi_bulb\r\n\r\n').encode()
+
+
+def _no_delay(writer):
+    """Отправлять каждую команду сразу: без этого система копит мелкие пакеты (алгоритм Нейгла)
+    и команда может задержаться на десятки–сотни миллисекунд — для мигания в такт это заметно."""
+    sock = writer.get_extra_info('socket')
+    if sock is not None:
+        try:
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        except OSError:
+            pass
+
+
+class YeelightError(Exception):
+    """Устройство не ответило или вернуло ошибку (например, «client quota exceeded»)."""
+
+
+@dataclass
+class Device:
+    id: str
+    ip: str
+    port: int = 55443
+    name: str = ''
+    model: str = ''
+    support: list = field(default_factory=list)
+    props: dict = field(default_factory=dict)   # power, bright, rgb, ct, … из ответа на поиск
+
+    @property
+    def color(self):
+        """Умеет ли цвет (а не только оттенки белого)."""
+        return 'set_rgb' in self.support or 'set_hsv' in self.support
+
+    @property
+    def music(self):
+        """Умеет ли музыкальный режим."""
+        return 'set_music' in self.support
+
+
+def _parse(data):
+    h = {}
+    for line in data.decode(errors='replace').split('\r\n')[1:]:
+        if ':' in line:
+            k, v = line.split(':', 1)
+            h[k.strip().lower()] = v.strip()
+    loc = h.get('location', '')
+    if not loc.startswith('yeelight://') or not h.get('id'):
+        return None
+    host, _, port = loc[len('yeelight://'):].partition(':')
+    props = {k: h[k] for k in ('power', 'bright', 'color_mode', 'ct', 'rgb', 'hue', 'sat') if k in h}
+    return Device(id=h['id'], ip=host, port=int(port or 55443), name=h.get('name', ''), model=h.get('model', ''),
+                  support=h.get('support', '').split(), props=props)
+
+
+def local_ips():
+    """Адреса IPv4 этого компьютера во всех сетях (Wi-Fi, кабель, VPN…), кроме служебных 169.254.*."""
+    ips = set()
+    try:
+        ips.update(i[4][0] for i in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET))
+    except OSError:
+        pass
+    for probe in ('192.168.0.1', '10.0.0.1', '8.8.8.8'):   # адрес, через который ходит обычный трафик
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            s.connect((probe, 1))
+            ips.add(s.getsockname()[0])
+        except OSError:
+            pass
+        finally:
+            s.close()
+    return sorted(ip for ip in ips if not ip.startswith(('127.', '169.254.', '0.')))
+
+
+def _send_search(s, target):
+    """Поиск в каждую сеть по отдельности: иначе система шлёт его только в одну — например,
+    в туннель VPN, — и лента в домашней сети его не услышит."""
+    if target != SSDP:
+        s.sendto(SEARCH, target)
+        return
+    for ip in local_ips() + ['127.0.0.1']:
+        try:
+            s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton(ip))
+            s.sendto(SEARCH, target)
+        except OSError:
+            pass
+
+
+def discover(timeout=2.0, target=SSDP):
+    """Найти устройства Yeelight в сети (блокирующий вызов, ~timeout секунд)."""
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+    s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2)
+    s.settimeout(0.3)
+    s.bind(('', 0))
+    found = {}
+    try:
+        end = time.time() + timeout
+        _send_search(s, target)
+        again = False
+        while time.time() < end:
+            if not again and time.time() > end - timeout / 2:
+                _send_search(s, target)   # UDP может потеряться — спросим ещё раз
+                again = True
+            try:
+                data, _ = s.recvfrom(4096)
+            except socket.timeout:
+                continue
+            d = _parse(data)
+            if d:
+                found[d.id] = d
+    finally:
+        s.close()
+    return list(found.values())
+
+
+class Bulb:
+    """Устройство Yeelight по адресу. Каждая команда — своё короткое соединение: так проще
+    переживать обрывы Wi-Fi и перезапуски устройства."""
+
+    def __init__(self, ip, port=55443, timeout=3.0):
+        self.ip, self.port, self.timeout = ip, port, timeout
+        self._id = 0
+
+    async def command(self, method, params=()):
+        """Отправить команду, вернуть result (список). YeelightError при ошибке или без ответа."""
+        try:
+            reader, writer = await asyncio.wait_for(asyncio.open_connection(self.ip, self.port), self.timeout)
+        except (OSError, asyncio.TimeoutError) as e:
+            raise YeelightError(f'нет связи с {self.ip}: {e}') from None
+        _no_delay(writer)
+        try:
+            self._id += 1
+            cid = self._id
+            writer.write(json.dumps({'id': cid, 'method': method, 'params': list(params)}).encode() + b'\r\n')
+            await writer.drain()
+            end = time.time() + self.timeout
+            while time.time() < end:
+                line = await asyncio.wait_for(reader.readline(), self.timeout)
+                if not line:
+                    break
+                msg = json.loads(line)
+                if msg.get('id') == cid:
+                    if 'error' in msg:
+                        raise YeelightError(str(msg['error'].get('message')))
+                    return msg.get('result')
+        except (OSError, ValueError, asyncio.TimeoutError) as e:
+            raise YeelightError(f'{method}: {e}') from None
+        finally:
+            writer.close()
+        raise YeelightError(f'{method}: нет ответа')
+
+    # удобные обёртки; effect — 'smooth' или 'sudden', duration — мс
+    async def get_props(self, *names):
+        names = names or ('power', 'bright', 'color_mode', 'rgb', 'ct', 'hue', 'sat', 'name')
+        return dict(zip(names, await self.command('get_prop', names)))
+
+    async def set_power(self, on, effect='smooth', duration=500):
+        return await self.command('set_power', ['on' if on else 'off', effect, duration])
+
+    async def set_rgb(self, rgb, effect='smooth', duration=500):
+        return await self.command('set_rgb', [int(rgb) & 0xffffff, effect, duration])
+
+    async def set_hsv(self, hue, sat, effect='smooth', duration=500):
+        return await self.command('set_hsv', [int(hue) % 360, max(0, min(100, int(sat))), effect, duration])
+
+    async def set_ct(self, kelvin, effect='smooth', duration=500):
+        return await self.command('set_ct_abx', [int(kelvin), effect, duration])
+
+    async def set_bright(self, percent, effect='smooth', duration=500):
+        return await self.command('set_bright', [max(1, min(100, int(percent))), effect, duration])
+
+    def music(self, local_ip=None):
+        return MusicMode(self, local_ip)
+
+
+class MusicMode:
+    """Музыкальный режим: устройство подключается к нам и принимает команды без ответа и лимита.
+
+        async with bulb.music() as m:
+            m.send('set_bright', [80, 'sudden', 30])
+    """
+
+    def __init__(self, bulb, local_ip=None):
+        self.bulb = bulb
+        self.local_ip = local_ip
+        self._server = None
+        self._conn = None
+
+    @property
+    def alive(self):
+        if not self._conn:
+            return False
+        r, w = self._conn
+        return not (w.is_closing() or r.at_eof())
+
+    async def start(self, timeout=5.0):
+        got = asyncio.get_running_loop().create_future()
+
+        def on_conn(r, w):
+            if got.done():
+                w.close()
+            else:
+                _no_delay(w)
+                got.set_result((r, w))
+        self._server = await asyncio.start_server(on_conn, '0.0.0.0', 0)
+        port = self._server.sockets[0].getsockname()[1]
+        ip = self.local_ip
+        if not ip:   # свой адрес, через который видно устройство
+            probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            try:
+                probe.connect((self.bulb.ip, 1))
+                ip = probe.getsockname()[0]
+            finally:
+                probe.close()
+        try:
+            await self.bulb.command('set_music', [1, ip, port])
+            self._conn = await asyncio.wait_for(got, timeout)
+        except (YeelightError, asyncio.TimeoutError) as e:
+            await self.stop()
+            raise YeelightError(f'музыкальный режим не включился: {e}') from None
+        return self
+
+    def send(self, method, params=()):
+        """Отправить команду (без ответа). False — соединение оборвалось."""
+        if not self.alive:
+            return False
+        try:
+            self._conn[1].write(json.dumps({'id': 1, 'method': method, 'params': list(params)}).encode() + b'\r\n')
+            return True
+        except (OSError, RuntimeError):
+            return False
+
+    async def stop(self):
+        if self._conn:
+            self._conn[1].close()
+            self._conn = None
+        if self._server:
+            self._server.close()
+            self._server = None
+
+    async def __aenter__(self):
+        return await self.start()
+
+    async def __aexit__(self, *exc):
+        await self.stop()

yeelight_lan-0.2.2/yeelight_lan/emulator.py

@@ -0,0 +1,350 @@
+"""Эмулятор ленты Yeelight (Lightstrip) — чтобы делать и проверять управление без настоящей ленты.
+
+Ведёт себя как лента с включённым «Управлением по локальной сети» (LAN control):
+- отвечает на поиск SSDP (239.255.255.250:1982, ST: wifi_bulb);
+- принимает команды JSON по TCP 55443: set_power, toggle, set_bright, set_rgb, set_hsv,
+  set_ct_abx, start_cf/stop_cf, get_prop, set_music, set_name;
+- как настоящая лента, ограничивает обычные команды: не больше 60 в минуту на соединение
+  (лишние получают ошибку «client quota exceeded»);
+- «музыкальный режим» (set_music [1, host, port]): лента сама подключается к host:port и
+  принимает оттуда команды без ответа и без ограничения частоты — так делают мигание в такт.
+
+Показ: http://<адрес компьютера>:47850 (с любого устройства дома) — полоса светится текущим цветом и яркостью, внизу журнал команд.
+
+    python -m yeelight_lan.emulator [--name "Лента"] [--port 55443] [--web 47850]
+
+Из своих проверок: strip = await yeelight_lan.emulator.start(port=0, web=None, ssdp=False)
+"""
+import argparse
+import asyncio
+import colorsys
+import hashlib
+import json
+import socket
+import struct
+
+import yeelight_lan
+import time
+
+from aiohttp import web
+
+SSDP_ADDR, SSDP_PORT = '239.255.255.250', 1982
+SUPPORT = ('get_prop set_default set_power toggle set_bright start_cf stop_cf set_scene cron_add cron_get '
+           'cron_del set_ct_abx set_rgb set_hsv set_adjust adjust_bright adjust_ct adjust_color set_music set_name')
+
+
+class Strip:
+    def __init__(self, name, port):
+        # постоянный номер: после перезапуска эмулятор — та же «лента», выбирать заново не надо
+        self.id = '0x' + hashlib.sha1(f'{socket.gethostname()}|{name}|{port}'.encode()).hexdigest()[:16]
+        self.name = name
+        self.port = port
+        self.power = 'on'
+        self.bright = 80
+        self.color_mode = 1           # 1 — rgb, 2 — ct, 3 — hsv
+        self.rgb = 0xff8800
+        self.ct = 4000
+        self.hue, self.sat = 30, 100
+        self.flowing = 0
+        self.music_on = 0
+        self.log = []                 # (время, откуда, команда)
+        self.changes = asyncio.Event()
+        self.quota = {}               # соединение -> [времена команд за минуту]
+        self.music_cmds = 0
+        self.music_started = 0
+        self.music_times = []         # time.perf_counter() прихода команд музыкального режима (для замеров)
+
+    # ---------- состояние ----------
+
+    def color_hex(self):
+        if self.color_mode == 2:   # белый: приблизим цвет по температуре
+            k = max(1700, min(6500, self.ct))
+            t = (k - 1700) / 4800
+            r, g, b = 255, int(170 + 70 * t), int(80 + 175 * t)
+            return '#%02x%02x%02x' % (r, g, b)
+        if self.color_mode == 3:
+            r, g, b = colorsys.hsv_to_rgb(self.hue / 360, self.sat / 100, 1)
+            return '#%02x%02x%02x' % (int(r * 255), int(g * 255), int(b * 255))
+        return '#%06x' % self.rgb
+
+    def props(self):
+        return {'power': self.power, 'bright': str(self.bright), 'ct': str(self.ct), 'rgb': str(self.rgb),
+                'hue': str(self.hue), 'sat': str(self.sat), 'color_mode': str(self.color_mode),
+                'flowing': str(self.flowing), 'music_on': str(self.music_on), 'name': self.name}
+
+    def note(self, src, text):
+        self.log.append((time.strftime('%H:%M:%S'), src, text))
+        del self.log[:-60]
+        self.changes.set()
+
+    # ---------- команды ----------
+
+    def run(self, method, params):
+        """-> result (список) или поднимает ValueError с текстом ошибки."""
+        if method == 'get_prop':
+            p = self.props()
+            return [p.get(k, '') for k in params]
+        if method == 'set_power':
+            self.power = params[0]
+        elif method == 'toggle':
+            self.power = 'off' if self.power == 'on' else 'on'
+        elif method == 'set_bright':
+            self.bright = max(1, min(100, int(params[0])))
+        elif method == 'set_rgb':
+            self.rgb = int(params[0]) & 0xffffff
+            self.color_mode = 1
+            self.power = 'on'
+        elif method == 'set_hsv':
+            self.hue, self.sat = int(params[0]) % 360, max(0, min(100, int(params[1])))
+            self.color_mode = 3
+            self.power = 'on'
+        elif method == 'set_ct_abx':
+            self.ct = max(1700, min(6500, int(params[0])))
+            self.color_mode = 2
+            self.power = 'on'
+        elif method == 'start_cf':
+            self.flowing = 1
+        elif method == 'stop_cf':
+            self.flowing = 0
+        elif method == 'set_name':
+            self.name = str(params[0])
+        elif method == 'set_music':
+            pass   # обрабатывается в соединении
+        else:
+            raise ValueError('method not supported')
+        return ['ok']
+
+
+class _Ssdp(asyncio.DatagramProtocol):
+    def __init__(self, strip):
+        self.strip = strip
+        self.transport = None
+
+    def connection_made(self, transport):
+        self.transport = transport
+
+    def datagram_received(self, data, addr):
+        text = data.decode(errors='replace')
+        if 'M-SEARCH' not in text or 'wifi_bulb' not in text:
+            return
+        # адрес, с которого нас видно этому клиенту
+        probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            probe.connect((addr[0], 1))
+            ip = probe.getsockname()[0]
+        finally:
+            probe.close()
+        strip, p = self.strip, self.strip.props()
+        reply = ('HTTP/1.1 200 OK\r\nCache-Control: max-age=3600\r\nDate: \r\nExt: \r\n'
+                 f'Location: yeelight://{ip}:{strip.port}\r\nServer: POSIX UPnP/1.0 YGLC/1\r\n'
+                 f'id: {strip.id}\r\nmodel: strip6\r\nfw_ver: 18\r\nsupport: {SUPPORT}\r\n'
+                 f'power: {p["power"]}\r\nbright: {p["bright"]}\r\ncolor_mode: {p["color_mode"]}\r\n'
+                 f'ct: {p["ct"]}\r\nrgb: {p["rgb"]}\r\nhue: {p["hue"]}\r\nsat: {p["sat"]}\r\nname: {p["name"]}\r\n\r\n')
+        self.transport.sendto(reply.encode(), addr)
+        strip.note(addr[0], 'поиск в сети → ответила')
+
+
+async def ssdp(strip):
+    """Отвечаем на поиск ленты в сети (DatagramProtocol — работает на Python 3.9+ и на всех системах)."""
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.bind(('', SSDP_PORT))
+    joined = set()
+
+    def join():
+        # слушаем поиск в каждой сети компьютера (а не только в той, что система считает главной —
+        # с VPN это туннель); сети появляются и пропадают, поэтому проверяем раз в 30 с
+        for ip in yeelight_lan.local_ips() + ['127.0.0.1']:
+            if ip in joined:
+                continue
+            try:
+                sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP,
+                                socket.inet_aton(SSDP_ADDR) + socket.inet_aton(ip))
+                joined.add(ip)
+            except OSError:
+                pass
+    join()
+    sock.setblocking(False)
+    loop = asyncio.get_running_loop()
+    transport, _ = await loop.create_datagram_endpoint(lambda: _Ssdp(strip), sock=sock)
+
+    async def rejoin():
+        while not transport.is_closing():
+            await asyncio.sleep(30)
+            join()
+    strip.ssdp_task = asyncio.create_task(rejoin())
+    return transport
+
+
+async def handle(strip, reader, writer):
+    peer = writer.get_extra_info('peername')[0]
+    times = []
+    strip.note(peer, 'подключение')
+    try:
+        while True:
+            line = await reader.readline()
+            if not line:
+                break
+            try:
+                cmd = json.loads(line)
+                cid, method, params = cmd.get('id'), cmd['method'], cmd.get('params', [])
+            except (ValueError, KeyError):
+                writer.write(b'{"id":0,"error":{"code":-1,"message":"invalid command"}}\r\n')
+                continue
+            now = time.time()
+            times[:] = [t for t in times if now - t < 60]
+            if len(times) >= 60 and method != 'get_prop':
+                writer.write(json.dumps({'id': cid, 'error': {'code': -1, 'message': 'client quota exceeded'}}).encode() + b'\r\n')
+                strip.note(peer, f'{method}: отказ — больше 60 команд в минуту')
+                continue
+            times.append(now)
+            if method == 'set_music':
+                if params and int(params[0]) == 1:
+                    asyncio.create_task(music(strip, params[1], int(params[2])))
+                    result = ['ok']
+                else:
+                    strip.music_on = 0
+                    result = ['ok']
+            else:
+                try:
+                    result = strip.run(method, params)
+                except (ValueError, IndexError, TypeError) as e:
+                    writer.write(json.dumps({'id': cid, 'error': {'code': -1, 'message': str(e)}}).encode() + b'\r\n')
+                    continue
+            writer.write(json.dumps({'id': cid, 'result': result}).encode() + b'\r\n')
+            if method != 'get_prop':
+                writer.write(json.dumps({'method': 'props', 'params': strip.props()}).encode() + b'\r\n')
+                strip.note(peer, f'{method} {params}')
+            await writer.drain()
+    except (ConnectionError, asyncio.IncompleteReadError):
+        pass
+    finally:
+        strip.note(peer, 'отключение')
+        writer.close()
+
+
+async def music(strip, host, port):
+    """Музыкальный режим: лента подключается к программе и слушает команды без ответов и лимита."""
+    try:
+        reader, writer = await asyncio.open_connection(host, port)
+    except OSError as e:
+        strip.note(host, f'музыкальный режим: не подключилась ({e})')
+        return
+    strip.music_on = 1
+    strip.music_started = time.time()
+    strip.music_cmds = 0
+    strip.note(host, f'музыкальный режим: подключилась к {host}:{port}')
+    try:
+        while strip.music_on:
+            line = await reader.readline()
+            if not line:
+                break
+            try:
+                cmd = json.loads(line)
+                strip.music_times.append(time.perf_counter())
+                del strip.music_times[:-500]
+                strip.run(cmd['method'], cmd.get('params', []))
+                strip.music_cmds += 1
+                strip.changes.set()
+            except (ValueError, KeyError, IndexError, TypeError):
+                pass
+    finally:
+        strip.music_on = 0
+        strip.note(host, f'музыкальный режим: закрыт ({strip.music_cmds} команд)')
+        writer.close()
+
+
+PAGE = '''<!doctype html><html lang="ru"><meta charset="utf-8"><title>Эмулятор ленты Yeelight</title>
+<style>
+body{margin:0;background:#0d0d0f;color:#eee;font:15px/1.4 system-ui,sans-serif;padding:32px}
+h1{font-size:20px;margin:0 0 4px}.sub{color:#888;margin-bottom:28px}
+.wall{height:220px;border-radius:14px;background:#141417;position:relative;overflow:hidden}
+.glow{position:absolute;inset:0;transition:background .12s, opacity .12s}
+.strip{position:absolute;left:6%;right:6%;top:46%;height:14px;border-radius:7px;transition:background .12s, box-shadow .12s, opacity .12s}
+.stats{display:flex;gap:28px;margin:18px 0;color:#aaa}.stats b{color:#fff;font-weight:600}
+.log{font:13px/1.6 ui-monospace,Consolas,monospace;color:#9a9aa5;max-height:300px;overflow:auto;background:#141417;border-radius:10px;padding:12px 14px}
+</style>
+<h1 id="name">Лента</h1><div class="sub">Эмулятор Yeelight Lightstrip · LAN 55443 · поиск SSDP</div>
+<div class="wall"><div class="glow" id="glow"></div><div class="strip" id="strip"></div></div>
+<div class="stats"><span>Питание: <b id="power"></b></span><span>Цвет: <b id="color"></b></span><span>Яркость: <b id="bright"></b></span>
+<span>Музыкальный режим: <b id="music"></b></span></div>
+<div class="log" id="log"></div>
+<script>
+const $=id=>document.getElementById(id);
+const es=new EventSource('/events');
+es.onmessage=e=>{const s=JSON.parse(e.data);
+ const on=s.power==='on', a=on?Math.max(.08,s.bright/100):0;
+ $('strip').style.background=on?s.hex:'#2a2a2e'; $('strip').style.opacity=on?(.35+.65*s.bright/100):1;
+ $('strip').style.boxShadow=on?`0 0 ${20+60*s.bright/100}px ${10+30*s.bright/100}px ${s.hex}`:'none';
+ $('glow').style.background=`radial-gradient(ellipse 70% 90% at 50% 50%, ${s.hex}, transparent 70%)`; $('glow').style.opacity=a*.6;
+ $('name').textContent=s.name; $('power').textContent=on?'вкл':'выкл'; $('color').textContent=s.hex.toUpperCase();
+ $('bright').textContent=s.bright+'%'; $('music').textContent=s.music?('да, '+s.music_rate+' команд/с'):'нет';
+ $('log').innerHTML=s.log.slice().reverse().map(l=>l.join('  ')).join('<br>');};
+</script>'''
+
+
+async def web_app(strip, port):
+    async def page(r):
+        return web.Response(text=PAGE, content_type='text/html')
+
+    async def events(r):
+        resp = web.StreamResponse(headers={'Content-Type': 'text/event-stream', 'Cache-Control': 'no-store'})
+        await resp.prepare(r)
+        last_n, last_t = 0, time.time()
+        try:
+            while True:
+                rate = (strip.music_cmds - last_n) / max(0.05, time.time() - last_t)
+                last_n, last_t = strip.music_cmds, time.time()
+                st = {'hex': strip.color_hex(), 'bright': strip.bright, 'power': strip.power, 'name': strip.name,
+                      'music': strip.music_on, 'music_rate': round(rate, 1), 'log': strip.log[-25:]}
+                await resp.write(f'data: {json.dumps(st, ensure_ascii=False)}\n\n'.encode())
+                strip.changes.clear()
+                try:
+                    await asyncio.wait_for(strip.changes.wait(), 0.5)
+                except asyncio.TimeoutError:
+                    pass
+                await asyncio.sleep(1 / 30)
+        except (ConnectionError, asyncio.CancelledError):
+            pass
+        return resp
+
+    app = web.Application()
+    app.add_routes([web.get('/', page), web.get('/events', events),
+                    web.get('/state', lambda r: web.json_response(dict(strip.props(), hex=strip.color_hex(),
+                                                                       music_cmds=strip.music_cmds)))])
+    runner = web.AppRunner(app)
+    await runner.setup()
+    await web.TCPSite(runner, '0.0.0.0', port).start()   # показ можно открыть с телефона или телевизора
+
+
+async def start(name='Лента (эмулятор)', port=55443, web=47850, ssdp=True, host='0.0.0.0'):
+    """Запустить эмулятор в текущем цикле asyncio. port=0 — любой свободный (смотри strip.port).
+    web=None — без страницы показа, ssdp=False — не отвечать на поиск в сети."""
+    strip = Strip(name, port)
+    server = await asyncio.start_server(lambda r, w: handle(strip, r, w), host, port)
+    strip.port = server.sockets[0].getsockname()[1]
+    strip.server = server
+    if web:
+        await web_app(strip, web)
+    strip.ssdp = None
+    if ssdp:
+        try:
+            strip.ssdp = await globals()['ssdp'](strip)
+        except OSError as e:   # порт 1982 занят — без поиска, по адресу подключиться можно
+            strip.note('-', f'поиск в сети недоступен: {e}')
+    return strip
+
+
+async def main():
+    ap = argparse.ArgumentParser(description='Эмулятор ленты Yeelight')
+    ap.add_argument('--name', default='Лента (эмулятор)')
+    ap.add_argument('--port', type=int, default=55443)
+    ap.add_argument('--web', type=int, default=47850)
+    a = ap.parse_args()
+    strip = await start(a.name, a.port, a.web)
+    print(f'Эмулятор ленты: LAN {strip.port}, показ http://<адрес компьютера>:{a.web}', flush=True)
+    await asyncio.Event().wait()
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

yeelight_lan-0.2.2/yeelight_lan.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: yeelight-lan
+Version: 0.2.2
+Summary: Yeelight over the home network: discovery, commands and music mode, plus a strip emulator
+Author: nowplaylab
+License: MIT
+Project-URL: Homepage, https://github.com/nowplaylab/yeelight-lan
+Project-URL: Issues, https://github.com/nowplaylab/yeelight-lan/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8
+Dynamic: license-file
+
+# yeelight-lan
+
+**English** | [Русский](https://github.com/nowplaylab/yeelight-lan/blob/main/README.ru.md)
+
+Control Yeelight lamps and light strips over your home network from Python: discovery, colour, brightness and **music mode** for flashing to the beat. No cloud, no account. Comes with a **strip emulator**, so you can build and test without the hardware.
+
+Made by [nowplaylab](https://github.com/nowplaylab) for [NowPlaying](https://github.com/nowplaylab/nowplaying-display), where a strip follows the album cover and pulses with the bass.
+
+## Install
+
+```
+pip install git+https://github.com/nowplaylab/yeelight-lan@v0.2.2
+```
+
+Python 3.9+. Turn on **LAN Control** for the device in the Yeelight app first.
+
+## Use
+
+```python
+import asyncio
+import yeelight_lan
+
+devices = yeelight_lan.discover()            # [Device(id, ip, name, model, ...)]
+bulb = yeelight_lan.Bulb(devices[0].ip)
+
+async def main():
+    await bulb.set_rgb(0xff6600)             # smooth change, 500 ms
+    await bulb.set_bright(70)
+    print(await bulb.get_props('power', 'bright', 'rgb'))
+
+    # music mode: the device connects to you and takes commands with no reply and no rate limit
+    async with bulb.music() as m:
+        for level in (20, 100, 40, 100):
+            m.send('set_bright', [level, 'sudden', 30])
+            await asyncio.sleep(0.25)
+
+asyncio.run(main())
+```
+
+Plain commands are limited by the device to **60 per minute per connection**; `Bulb` opens a short connection per command, which also survives Wi-Fi drops and device restarts. For anything faster, use `MusicMode`.
+
+## Emulator
+
+```
+python -m yeelight_lan.emulator
+```
+
+Pretends to be a Yeelight strip with LAN control on: answers discovery, takes commands on port 55443, enforces the 60/min limit and supports music mode. Open `http://<computer address>:47850` on any device at home to see the strip glow with whatever it was sent, plus a log of commands.
+
+From tests:
+
+```python
+strip = await yeelight_lan.emulator.start(port=0, web=None, ssdp=False)
+bulb = yeelight_lan.Bulb('127.0.0.1', strip.port)
+```
+
+## Licence
+
+MIT.

yeelight_lan-0.2.2/yeelight_lan.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+tests/test_yeelight.py
+yeelight_lan/__init__.py
+yeelight_lan/emulator.py
+yeelight_lan.egg-info/PKG-INFO
+yeelight_lan.egg-info/SOURCES.txt
+yeelight_lan.egg-info/dependency_links.txt
+yeelight_lan.egg-info/requires.txt
+yeelight_lan.egg-info/top_level.txt

yeelight_lan-0.2.2/yeelight_lan.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yeelight_lan-0.2.2/yeelight_lan.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.8

yeelight_lan-0.2.2/yeelight_lan.egg-info/top_level.txt

@@ -0,0 +1 @@
+yeelight_lan