pulse5ctl 1.3.0__tar.gz

pulse5ctl-1.3.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pulse5ctl
+Version: 1.3.0
+Summary: CLI & MCP server for JBL Pulse 5 LED control over BLE
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: bleak>=0.21.0
+Requires-Dist: click>=8.0
+Requires-Dist: mcp>=1.2.0

pulse5ctl-1.3.0/pulse5/ble.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import asyncio
+import platform
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import AsyncIterator, Callable
+
+from bleak import BleakClient, BleakScanner
+from bleak.backends.device import BLEDevice
+from bleak.backends.scanner import AdvertisementData
+
+from pulse5.protocol.constants import PulseConstants as C
+
+
+@dataclass
+class DiscoveredDevice:
+    address: str
+    name: str
+    rssi: int
+
+
+async def _find_connected_peripherals(scanner: BleakScanner) -> list[DiscoveredDevice]:
+    if platform.system() != "Darwin":
+        return []
+    try:
+        import CoreBluetooth
+
+        cbmgr = scanner._backend._manager
+        service = CoreBluetooth.CBUUID.UUIDWithString_(C.SERVICE_UUID)
+        peripherals = cbmgr.central_manager.retrieveConnectedPeripheralsWithServices_(
+            [service]
+        )
+        results = []
+        for p in peripherals:
+            name = str(p.name()) if p.name() else "JBL Pulse 5"
+            uuid = str(p.identifier())
+            results.append(DiscoveredDevice(address=uuid, name=name, rssi=0))
+        return results
+    except Exception:
+        return []
+
+
+async def scan(timeout: float = 5.0) -> list[DiscoveredDevice]:
+    devices: dict[str, DiscoveredDevice] = {}
+
+    def callback(device: BLEDevice, adv: AdvertisementData) -> None:
+        name = adv.local_name or device.name or ""
+        has_service = C.SERVICE_UUID.lower() in [s.lower() for s in (adv.service_uuids or [])]
+        is_jbl = has_service or name.startswith(C.DEVICE_NAME_PREFIX)
+        if is_jbl:
+            devices[device.address] = DiscoveredDevice(
+                address=device.address,
+                name=name or "Unknown",
+                rssi=adv.rssi if adv.rssi is not None else -100,
+            )
+
+    scanner = BleakScanner(detection_callback=callback)
+    await scanner.start()
+
+    for dev in await _find_connected_peripherals(scanner):
+        devices[dev.address] = dev
+
+    await asyncio.sleep(timeout)
+    await scanner.stop()
+
+    return sorted(devices.values(), key=lambda d: d.rssi, reverse=True)
+
+
+async def _resolve_device(address: str) -> BLEDevice | str:
+    if platform.system() != "Darwin":
+        return address
+    try:
+        from Foundation import NSUUID
+
+        scanner = BleakScanner(service_uuids=[C.SERVICE_UUID])
+        await scanner.start()
+        await asyncio.sleep(0.5)
+
+        cbmgr = scanner._backend._manager
+        cm = cbmgr.central_manager
+
+        ns_uuid = NSUUID.alloc().initWithUUIDString_(address)
+        peripherals = cm.retrievePeripheralsWithIdentifiers_([ns_uuid])
+
+        await scanner.stop()
+
+        if peripherals and len(peripherals) > 0:
+            peripheral = peripherals[0]
+            return BLEDevice(
+                address=str(peripheral.identifier()),
+                name=str(peripheral.name()) if peripheral.name() else "JBL Pulse 5",
+                details=(peripheral, cbmgr),
+            )
+    except Exception:
+        pass
+    return address
+
+
+@asynccontextmanager
+async def connect(address: str) -> AsyncIterator[BleakClient]:
+    last_error: Exception | None = None
+    device = await _resolve_device(address)
+
+    for attempt in range(C.MAX_RECONNECT_ATTEMPTS):
+        try:
+            client = BleakClient(device)
+            await client.connect()
+            try:
+                yield client
+            finally:
+                if client.is_connected:
+                    await client.disconnect()
+            return
+        except Exception as e:
+            last_error = e
+            if attempt < C.MAX_RECONNECT_ATTEMPTS - 1:
+                delay = C.BASE_RECONNECT_DELAY * (2 ** attempt)
+                await asyncio.sleep(delay)
+
+    raise ConnectionError(
+        f"Failed to connect after {C.MAX_RECONNECT_ATTEMPTS} attempts: {last_error}"
+    )
+
+
+async def write(client: BleakClient, data: bytes) -> None:
+    char = client.services.get_characteristic(C.WRITE_CHAR_UUID)
+    if char is None:
+        raise RuntimeError(f"Write characteristic {C.WRITE_CHAR_UUID} not found")
+    response = "write" in char.properties
+    await client.write_gatt_char(char, data, response=response)
+
+
+async def subscribe(client: BleakClient, callback: Callable[[bytearray], None]) -> None:
+    char = client.services.get_characteristic(C.READ_CHAR_UUID)
+    if char is None:
+        raise RuntimeError(f"Read characteristic {C.READ_CHAR_UUID} not found")
+
+    def handler(_sender: int, data: bytearray) -> None:
+        callback(data)
+
+    await client.start_notify(char, handler)

pulse5ctl-1.3.0/pulse5/cli.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+
+import click
+
+from pulse5 import ble, config
+from pulse5.protocol.codec import PulseCodec
+from pulse5.protocol.models import PATTERN_BY_NAME, THEME_BY_NAME, ColorEffect
+
+
+def _run(coro):
+    return asyncio.run(coro)
+
+
+def _get_address(address: str | None) -> str:
+    if address:
+        return address
+    saved = config.get_saved_device()
+    if saved:
+        return saved[0]
+    click.echo("Error: No device specified. Run 'pulse5 scan' first or pass --address.", err=True)
+    sys.exit(1)
+
+
+@click.group()
+@click.option("--address", "-a", default=None, help="Device BLE address.")
+@click.pass_context
+def cli(ctx: click.Context, address: str | None) -> None:
+    """Control JBL Pulse 5 speaker LEDs over Bluetooth."""
+    ctx.ensure_object(dict)
+    ctx.obj["address"] = address
+
+
+@cli.command()
+@click.option("--timeout", "-t", default=5.0, help="Scan duration in seconds.")
+def scan(timeout: float) -> None:
+    """Discover nearby JBL Pulse 5 speakers."""
+
+    async def _scan():
+        click.echo(f"Scanning for {timeout}s...")
+        devices = await ble.scan(timeout=timeout)
+        if not devices:
+            click.echo("No JBL Pulse 5 speakers found.")
+            return
+        click.echo(f"Found {len(devices)} device(s):\n")
+        for d in devices:
+            click.echo(f"  {d.name}")
+            click.echo(f"    Address: {d.address}")
+            click.echo(f"    RSSI:    {d.rssi} dBm")
+            click.echo()
+        best = devices[0]
+        config.save_device(best.address, best.name)
+        click.echo(f"Saved '{best.name}' ({best.address}) as default device.")
+
+    _run(_scan())
+
+
+@cli.command()
+@click.argument("level", type=click.IntRange(20, 80))
+@click.pass_context
+def brightness(ctx: click.Context, level: int) -> None:
+    """Set brightness level (20-80)."""
+    address = _get_address(ctx.obj["address"])
+
+    async def _cmd():
+        async with ble.connect(address) as client:
+            await ble.write(client, PulseCodec.set_led_brightness(level))
+            click.echo(f"Brightness set to {level}.")
+
+    _run(_cmd())
+
+
+@cli.command()
+@click.argument("name", type=click.Choice(list(THEME_BY_NAME.keys()), case_sensitive=False))
+@click.pass_context
+def theme(ctx: click.Context, name: str) -> None:
+    """Set LED theme."""
+    address = _get_address(ctx.obj["address"])
+    t = THEME_BY_NAME[name.lower()]
+
+    async def _cmd():
+        async with ble.connect(address) as client:
+            await ble.write(client, PulseCodec.switch_package(t.value))
+            click.echo(f"Theme set to {t.display_name}.")
+
+    _run(_cmd())
+
+
+@cli.command()
+@click.argument("name", type=click.Choice(list(PATTERN_BY_NAME.keys()), case_sensitive=False))
+@click.pass_context
+def pattern(ctx: click.Context, name: str) -> None:
+    """Set an LED pattern."""
+    address = _get_address(ctx.obj["address"])
+    p = PATTERN_BY_NAME[name.lower()]
+    t = p.theme
+    all_pats = [pat.value for pat in t.patterns]
+    ordered = [p.value] + [v for v in all_pats if v != p.value]
+
+    async def _cmd():
+        async with ble.connect(address) as client:
+            await ble.write(client, PulseCodec.set_led_package(
+                package_id=t.value,
+                active_patterns=[p.value],
+                all_patterns=ordered,
+                color_effect=ColorEffect.COLOR_LOOP.value,
+                red=0xFF, green=0xFF, blue=0xFF,
+            ))
+            click.echo(f"Pattern set to {p.display_name}.")
+
+    _run(_cmd())
+
+
+@cli.command()
+@click.pass_context
+def status(ctx: click.Context) -> None:
+    """Query current speaker state."""
+    address = _get_address(ctx.obj["address"])
+
+    async def _cmd():
+        results: dict[str, object] = {}
+
+        def on_notify(data: bytearray) -> None:
+            brt = PulseCodec.parse_brightness_state(data)
+            if brt is not None:
+                results["brightness"] = brt
+            thm = PulseCodec.parse_selected_theme(data)
+            if thm is not None:
+                results["theme"] = thm
+
+        async with ble.connect(address) as client:
+            await ble.subscribe(client, on_notify)
+            await ble.write(client, PulseCodec.request_led_brightness())
+            await asyncio.sleep(0.5)
+            await ble.write(client, PulseCodec.request_led_package_info())
+            await asyncio.sleep(0.5)
+
+        click.echo("Speaker Status:")
+        if "brightness" in results:
+            brt = results["brightness"]
+            click.echo(f"  Brightness: {brt.level}")
+        if "theme" in results:
+            click.echo(f"  Theme:      {results['theme'].display_name}")
+
+    _run(_cmd())
+
+
+def main() -> None:
+    cli()
+
+
+if __name__ == "__main__":
+    main()

pulse5ctl-1.3.0/pulse5/config.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "pulse5"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def _load() -> dict:
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+    return {}
+
+
+def _save(data: dict) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(data, indent=2) + "\n")
+
+
+def get_saved_device() -> tuple[str, str] | None:
+    data = _load()
+    addr = data.get("address")
+    name = data.get("name")
+    if addr:
+        return (addr, name or "Unknown")
+    return None
+
+
+def save_device(address: str, name: str) -> None:
+    data = _load()
+    data["address"] = address
+    data["name"] = name
+    _save(data)
+
+
+def clear_device() -> None:
+    data = _load()
+    data.pop("address", None)
+    data.pop("name", None)
+    _save(data)

pulse5ctl-1.3.0/pulse5/mcp_server.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import asyncio
+import sys
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("pulse5")
+
+
+async def _run_pulse5(*args: str) -> str:
+    proc = await asyncio.create_subprocess_exec(
+        sys.executable, "-m", "pulse5.cli", *args,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        stdin=asyncio.subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    stdout, stderr = await proc.communicate()
+    output = stdout.decode().strip()
+    if proc.returncode != 0:
+        err = stderr.decode().strip()
+        return f"Failed: {err or output or f'exit code {proc.returncode}'}"
+    return output or "Done."
+
+
+@mcp.tool()
+async def pulse5_scan(timeout: float = 5) -> str:
+    """Discover nearby JBL Pulse 5 speakers via BLE."""
+    return await _run_pulse5("scan", "--timeout", str(timeout))
+
+
+@mcp.tool()
+async def pulse5_brightness(level: int) -> str:
+    """Set speaker LED brightness (20-80)."""
+    return await _run_pulse5("brightness", str(level))
+
+
+@mcp.tool()
+async def pulse5_theme(name: str) -> str:
+    """Set LED theme. Options: nature, party, spiritual, cocktail, weather."""
+    return await _run_pulse5("theme", name)
+
+
+@mcp.tool()
+async def pulse5_pattern(name: str) -> str:
+    """Set LED pattern. Options: campfire, northern lights, sea wave, universe, strobe, equalizer, geometry, spin, rainbow, dynamic wave, lava, focus, sky sunny, rain, snow, thunder, cloud, fruit gin, mojito, tequila, cherry."""
+    return await _run_pulse5("pattern", name)
+
+
+@mcp.tool()
+async def pulse5_status() -> str:
+    """Query current speaker state (brightness, theme)."""
+    return await _run_pulse5("status")
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

pulse5ctl-1.3.0/pulse5/protocol/codec.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pulse5.protocol.constants import PulseConstants as C
+from pulse5.protocol.models import LEDTheme
+
+
+@dataclass
+class Response:
+    command_id: int
+    payload: bytes
+
+
+@dataclass
+class BrightnessState:
+    level: int
+    body_light_on: bool
+    projection_on: bool
+
+
+class PulseCodec:
+
+    @staticmethod
+    def request_speaker_info() -> bytes:
+        return bytes([C.HEADER, C.CMD_REQ_SPEAKER_INFO, 0x00])
+
+    @staticmethod
+    def switch_package(package_id: int) -> bytes:
+        return bytes([C.HEADER, C.CMD_SWITCH_LED_PACKAGE, 0x01, package_id])
+
+    @staticmethod
+    def set_led_brightness(level: int, body_light: bool = True, projection: bool = True) -> bytes:
+        clamped = min(max(level, C.MIN_BRIGHTNESS), C.MAX_BRIGHTNESS)
+        return bytes([
+            C.HEADER,
+            C.CMD_SET_LED_BRIGHTNESS,
+            0x03,
+            clamped,
+            1 if body_light else 0,
+            1 if projection else 0,
+        ])
+
+    @staticmethod
+    def request_led_brightness() -> bytes:
+        return bytes([C.HEADER, C.CMD_REQ_LED_BRIGHTNESS, 0x00])
+
+    @staticmethod
+    def request_led_package_info() -> bytes:
+        return bytes([C.HEADER, C.CMD_REQ_LED_PACKAGE_INFO, 0x00])
+
+    @staticmethod
+    def set_led_package(
+        package_id: int,
+        active_patterns: list[int],
+        all_patterns: list[int],
+        color_effect: int,
+        red: int,
+        green: int,
+        blue: int,
+    ) -> bytes:
+        all_count = len(all_patterns)
+        active_count = len(active_patterns)
+        length = all_count + 7
+
+        data = bytearray([
+            C.HEADER,
+            C.CMD_SET_LED_PACKAGE,
+            length,
+            package_id,
+            active_count,
+            all_count,
+        ])
+        data.extend(all_patterns)
+        data.extend([color_effect, red, green, blue])
+        return bytes(data)
+
+    @staticmethod
+    def parse(data: bytes | bytearray) -> Response | None:
+        if len(data) < 3 or data[0] != C.HEADER:
+            return None
+        command_id = data[1]
+        length = data[2]
+        payload = bytes(data[3 : 3 + length])
+        return Response(command_id=command_id, payload=payload)
+
+    @staticmethod
+    def parse_brightness_state(data: bytes | bytearray) -> BrightnessState | None:
+        response = PulseCodec.parse(data)
+        if response is None or response.command_id != C.CMD_RET_LED_BRIGHTNESS:
+            return None
+        if len(response.payload) < 3:
+            return None
+        return BrightnessState(
+            level=response.payload[0],
+            body_light_on=response.payload[1] != 0,
+            projection_on=response.payload[2] != 0,
+        )
+
+    @staticmethod
+    def parse_selected_theme(data: bytes | bytearray) -> LEDTheme | None:
+        response = PulseCodec.parse(data)
+        if response is None or response.command_id != C.CMD_RET_LED_PACKAGE_INFO:
+            return None
+        if len(response.payload) < 2:
+            return None
+        try:
+            return LEDTheme(response.payload[1])
+        except ValueError:
+            return None

pulse5ctl-1.3.0/pulse5/protocol/constants.py

@@ -0,0 +1,26 @@
+class PulseConstants:
+    SERVICE_UUID = "65786365-6c70-6f69-6e74-2e636f6d0000"
+    WRITE_CHAR_UUID = "65786365-6c70-6f69-6e74-2e636f6d0002"
+    READ_CHAR_UUID = "65786365-6c70-6f69-6e74-2e636f6d0001"
+
+    HEADER = 0xAA
+
+    CMD_REQ_SPEAKER_INFO = 0x11
+
+    CMD_REQ_LED_PACKAGE_INFO = 0x83
+    CMD_RET_LED_PACKAGE_INFO = 0x84
+    CMD_SET_LED_PACKAGE = 0x85
+
+    CMD_SET_LED_BRIGHTNESS = 0x8A
+    CMD_REQ_LED_BRIGHTNESS = 0x8B
+    CMD_RET_LED_BRIGHTNESS = 0x8C
+
+    CMD_SWITCH_LED_PACKAGE = 0x90
+
+    MIN_BRIGHTNESS = 20
+    MAX_BRIGHTNESS = 80
+
+    DEVICE_NAME_PREFIX = "JBL"
+
+    MAX_RECONNECT_ATTEMPTS = 3
+    BASE_RECONNECT_DELAY = 1.0

pulse5ctl-1.3.0/pulse5/protocol/models.py

@@ -0,0 +1,138 @@
+from enum import IntEnum
+
+
+class LEDTheme(IntEnum):
+    NATURE = 0x01
+    PARTY = 0x02
+    SPIRITUAL = 0x03
+    COCKTAIL = 0x04
+    WEATHER = 0x05
+    CANVAS = 0xC1
+
+    @property
+    def display_name(self) -> str:
+        return _THEME_NAMES[self]
+
+    @property
+    def patterns(self) -> list["LEDPattern"]:
+        return list(_THEME_PATTERNS[self])
+
+
+class LEDPattern(IntEnum):
+    CAMPFIRE = 0x01
+    NORTHERN_LIGHTS = 0x02
+    SEA_WAVE = 0x03
+    UNIVERSE = 0x04
+    STROBE = 0x05
+    EQUALIZER = 0x06
+    GEOMETRY = 0x07
+    SPIN = 0x08
+    RAINBOW = 0x09
+    DYNAMIC_WAVE = 0x0A
+    LAVA = 0x0B
+    FOCUS = 0x0C
+    SKY_SUNNY = 0x0D
+    RAIN = 0x0E
+    SNOW = 0x0F
+    THUNDER = 0x10
+    CLOUD = 0x11
+    FRUIT_GIN = 0x13
+    MOJITO = 0x14
+    TEQUILA = 0x15
+    CHERRY = 0x16
+
+    @property
+    def display_name(self) -> str:
+        return _PATTERN_NAMES[self]
+
+    @property
+    def theme(self) -> LEDTheme:
+        return _PATTERN_TO_THEME[self]
+
+
+class ColorEffect(IntEnum):
+    STATIC = 0
+    COLOR_LOOP = 1
+
+
+_THEME_NAMES: dict[LEDTheme, str] = {
+    LEDTheme.NATURE: "Nature",
+    LEDTheme.PARTY: "Party",
+    LEDTheme.SPIRITUAL: "Spiritual",
+    LEDTheme.COCKTAIL: "Cocktail",
+    LEDTheme.WEATHER: "Weather",
+    LEDTheme.CANVAS: "Canvas",
+}
+
+_PATTERN_NAMES: dict[LEDPattern, str] = {
+    LEDPattern.CAMPFIRE: "Campfire",
+    LEDPattern.NORTHERN_LIGHTS: "Northern Lights",
+    LEDPattern.SEA_WAVE: "Sea Wave",
+    LEDPattern.UNIVERSE: "Universe",
+    LEDPattern.STROBE: "Strobe",
+    LEDPattern.EQUALIZER: "Equalizer",
+    LEDPattern.GEOMETRY: "Geometry",
+    LEDPattern.SPIN: "Spin",
+    LEDPattern.RAINBOW: "Rainbow",
+    LEDPattern.DYNAMIC_WAVE: "Dynamic Wave",
+    LEDPattern.LAVA: "Lava",
+    LEDPattern.FOCUS: "Focus",
+    LEDPattern.SKY_SUNNY: "Sky Sunny",
+    LEDPattern.RAIN: "Rain",
+    LEDPattern.SNOW: "Snow",
+    LEDPattern.THUNDER: "Thunder",
+    LEDPattern.CLOUD: "Cloud",
+    LEDPattern.FRUIT_GIN: "Fruit Gin",
+    LEDPattern.MOJITO: "Mojito",
+    LEDPattern.TEQUILA: "Tequila",
+    LEDPattern.CHERRY: "Cherry",
+}
+
+_THEME_PATTERNS: dict[LEDTheme, tuple[LEDPattern, ...]] = {
+    LEDTheme.NATURE: (
+        LEDPattern.CAMPFIRE,
+        LEDPattern.NORTHERN_LIGHTS,
+        LEDPattern.SEA_WAVE,
+        LEDPattern.UNIVERSE,
+    ),
+    LEDTheme.PARTY: (
+        LEDPattern.STROBE,
+        LEDPattern.EQUALIZER,
+        LEDPattern.GEOMETRY,
+        LEDPattern.SPIN,
+        LEDPattern.RAINBOW,
+    ),
+    LEDTheme.SPIRITUAL: (
+        LEDPattern.DYNAMIC_WAVE,
+        LEDPattern.LAVA,
+        LEDPattern.FOCUS,
+    ),
+    LEDTheme.COCKTAIL: (
+        LEDPattern.FRUIT_GIN,
+        LEDPattern.MOJITO,
+        LEDPattern.TEQUILA,
+        LEDPattern.CHERRY,
+    ),
+    LEDTheme.WEATHER: (
+        LEDPattern.SKY_SUNNY,
+        LEDPattern.RAIN,
+        LEDPattern.SNOW,
+        LEDPattern.THUNDER,
+        LEDPattern.CLOUD,
+    ),
+    LEDTheme.CANVAS: (),
+}
+
+_PATTERN_TO_THEME: dict[LEDPattern, LEDTheme] = {
+    pattern: theme
+    for theme, patterns in _THEME_PATTERNS.items()
+    for pattern in patterns
+}
+
+THEME_BY_NAME: dict[str, LEDTheme] = {
+    t.display_name.lower(): t for t in LEDTheme if t != LEDTheme.CANVAS
+}
+
+PATTERN_BY_NAME: dict[str, LEDPattern] = {
+    p.display_name.lower(): p for p in LEDPattern
+}

pulse5ctl-1.3.0/pulse5ctl.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: pulse5ctl
+Version: 1.3.0
+Summary: CLI & MCP server for JBL Pulse 5 LED control over BLE
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: bleak>=0.21.0
+Requires-Dist: click>=8.0
+Requires-Dist: mcp>=1.2.0

pulse5ctl-1.3.0/pulse5ctl.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+pyproject.toml
+pulse5/__init__.py
+pulse5/ble.py
+pulse5/cli.py
+pulse5/config.py
+pulse5/mcp_server.py
+pulse5/protocol/__init__.py
+pulse5/protocol/codec.py
+pulse5/protocol/constants.py
+pulse5/protocol/models.py
+pulse5ctl.egg-info/PKG-INFO
+pulse5ctl.egg-info/SOURCES.txt
+pulse5ctl.egg-info/dependency_links.txt
+pulse5ctl.egg-info/entry_points.txt
+pulse5ctl.egg-info/requires.txt
+pulse5ctl.egg-info/top_level.txt
+tests/test_codec.py
+tests/test_config.py
+tests/test_models.py

pulse5ctl-1.3.0/pulse5ctl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pulse5ctl-1.3.0/pulse5ctl.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pulse5 = pulse5.cli:main
+pulse5-mcp = pulse5.mcp_server:main

pulse5ctl-1.3.0/pulse5ctl.egg-info/requires.txt

@@ -0,0 +1,3 @@
+bleak>=0.21.0
+click>=8.0
+mcp>=1.2.0

pulse5ctl-1.3.0/pulse5ctl.egg-info/top_level.txt

@@ -0,0 +1 @@
+pulse5

pulse5ctl-1.3.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pulse5ctl"
+version = "1.3.0"
+description = "CLI & MCP server for JBL Pulse 5 LED control over BLE"
+license = "MIT"
+requires-python = ">=3.10"
+dependencies = [
+    "bleak>=0.21.0",
+    "click>=8.0",
+    "mcp>=1.2.0",
+]
+
+[project.scripts]
+pulse5 = "pulse5.cli:main"
+pulse5-mcp = "pulse5.mcp_server:main"
+
+[tool.setuptools.packages.find]
+include = ["pulse5*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pulse5ctl-1.3.0/setup.cfg

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

pulse5ctl-1.3.0/tests/test_codec.py

@@ -0,0 +1,103 @@
+from pulse5.protocol.codec import PulseCodec, BrightnessState
+from pulse5.protocol.constants import PulseConstants as C
+from pulse5.protocol.models import LEDTheme
+
+
+class TestEncoding:
+    def test_set_led_brightness(self):
+        assert PulseCodec.set_led_brightness(60) == bytes([0xAA, 0x8A, 0x03, 60, 1, 1])
+
+    def test_set_led_brightness_clamps_low(self):
+        assert PulseCodec.set_led_brightness(0)[3] == C.MIN_BRIGHTNESS
+
+    def test_set_led_brightness_clamps_high(self):
+        assert PulseCodec.set_led_brightness(255)[3] == C.MAX_BRIGHTNESS
+
+    def test_set_led_brightness_body_off(self):
+        assert PulseCodec.set_led_brightness(50, body_light=False) == bytes([0xAA, 0x8A, 0x03, 50, 0, 1])
+
+    def test_set_led_brightness_projection_off(self):
+        assert PulseCodec.set_led_brightness(50, projection=False) == bytes([0xAA, 0x8A, 0x03, 50, 1, 0])
+
+    def test_request_speaker_info(self):
+        assert PulseCodec.request_speaker_info() == bytes([0xAA, 0x11, 0x00])
+
+    def test_request_led_brightness(self):
+        assert PulseCodec.request_led_brightness() == bytes([0xAA, 0x8B, 0x00])
+
+    def test_request_led_package_info(self):
+        assert PulseCodec.request_led_package_info() == bytes([0xAA, 0x83, 0x00])
+
+    def test_switch_package(self):
+        assert PulseCodec.switch_package(0x02) == bytes([0xAA, 0x90, 0x01, 0x02])
+
+    def test_set_led_package_static_color(self):
+        result = PulseCodec.set_led_package(
+            package_id=0xC1, active_patterns=[], all_patterns=[],
+            color_effect=0, red=255, green=0, blue=0,
+        )
+        assert result == bytes([0xAA, 0x85, 0x07, 0xC1, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00])
+
+    def test_set_led_package_with_patterns(self):
+        result = PulseCodec.set_led_package(
+            package_id=0x01, active_patterns=[0x01, 0x02], all_patterns=[0x01, 0x02, 0x03, 0x04],
+            color_effect=1, red=0xFF, green=0xFF, blue=0xFF,
+        )
+        assert result == bytes([
+            0xAA, 0x85, 0x0B, 0x01, 0x02, 0x04,
+            0x01, 0x02, 0x03, 0x04,
+            0x01, 0xFF, 0xFF, 0xFF,
+        ])
+
+
+class TestDecoding:
+    def test_parse_valid(self):
+        resp = PulseCodec.parse(bytes([0xAA, 0x72, 0x01, 0x01]))
+        assert resp is not None
+        assert resp.command_id == 0x72
+        assert resp.payload == bytes([0x01])
+
+    def test_parse_bad_header(self):
+        assert PulseCodec.parse(bytes([0xBB, 0x72, 0x01])) is None
+
+    def test_parse_too_short(self):
+        assert PulseCodec.parse(bytes([0xAA, 0x72])) is None
+
+    def test_parse_empty_payload(self):
+        resp = PulseCodec.parse(bytes([0xAA, 0x11, 0x00]))
+        assert resp is not None
+        assert resp.payload == b""
+
+    def test_parse_brightness_state(self):
+        brt = PulseCodec.parse_brightness_state(bytes([0xAA, 0x8C, 0x03, 50, 1, 1]))
+        assert brt == BrightnessState(level=50, body_light_on=True, projection_on=True)
+
+    def test_parse_brightness_state_lights_off(self):
+        brt = PulseCodec.parse_brightness_state(bytes([0xAA, 0x8C, 0x03, 30, 0, 0]))
+        assert brt == BrightnessState(level=30, body_light_on=False, projection_on=False)
+
+    def test_parse_brightness_wrong_cmd(self):
+        assert PulseCodec.parse_brightness_state(bytes([0xAA, 0x72, 0x03, 50, 1, 1])) is None
+
+    def test_parse_brightness_short_payload(self):
+        assert PulseCodec.parse_brightness_state(bytes([0xAA, 0x8C, 0x02, 50, 1])) is None
+
+    def test_parse_selected_theme_party(self):
+        assert PulseCodec.parse_selected_theme(bytes([0xAA, 0x84, 0x02, 0x00, 0x02])) == LEDTheme.PARTY
+
+    def test_parse_selected_theme_nature(self):
+        assert PulseCodec.parse_selected_theme(bytes([0xAA, 0x84, 0x02, 0x00, 0x01])) == LEDTheme.NATURE
+
+    def test_parse_selected_theme_wrong_cmd(self):
+        assert PulseCodec.parse_selected_theme(bytes([0xAA, 0x72, 0x02, 0x00, 0x02])) is None
+
+    def test_parse_selected_theme_short_payload(self):
+        assert PulseCodec.parse_selected_theme(bytes([0xAA, 0x84, 0x01, 0x00])) is None
+
+    def test_parse_selected_theme_unknown_value(self):
+        assert PulseCodec.parse_selected_theme(bytes([0xAA, 0x84, 0x02, 0x00, 0xFF])) is None
+
+    def test_parse_bytearray(self):
+        resp = PulseCodec.parse(bytearray([0xAA, 0x72, 0x01, 0x01]))
+        assert resp is not None
+        assert resp.command_id == 0x72

pulse5ctl-1.3.0/tests/test_config.py

@@ -0,0 +1,42 @@
+import json
+
+from pulse5 import config
+
+
+class TestConfig:
+    def test_save_and_load(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
+        monkeypatch.setattr(config, "CONFIG_FILE", tmp_path / "config.json")
+
+        config.save_device("AA:BB:CC:DD:EE:FF", "JBL Pulse 5")
+        result = config.get_saved_device()
+        assert result == ("AA:BB:CC:DD:EE:FF", "JBL Pulse 5")
+
+    def test_no_saved_device(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
+        monkeypatch.setattr(config, "CONFIG_FILE", tmp_path / "config.json")
+
+        assert config.get_saved_device() is None
+
+    def test_clear_device(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
+        monkeypatch.setattr(config, "CONFIG_FILE", tmp_path / "config.json")
+
+        config.save_device("AA:BB:CC:DD:EE:FF", "JBL Pulse 5")
+        config.clear_device()
+        assert config.get_saved_device() is None
+
+    def test_corrupt_config(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
+        monkeypatch.setattr(config, "CONFIG_FILE", tmp_path / "config.json")
+
+        (tmp_path / "config.json").write_text("not json{{{")
+        assert config.get_saved_device() is None
+
+    def test_missing_name_defaults(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(config, "CONFIG_DIR", tmp_path)
+        monkeypatch.setattr(config, "CONFIG_FILE", tmp_path / "config.json")
+
+        (tmp_path / "config.json").write_text(json.dumps({"address": "AA:BB"}))
+        result = config.get_saved_device()
+        assert result == ("AA:BB", "Unknown")

pulse5ctl-1.3.0/tests/test_models.py

@@ -0,0 +1,98 @@
+from pulse5.protocol.models import (
+    PATTERN_BY_NAME,
+    THEME_BY_NAME,
+    ColorEffect,
+    LEDPattern,
+    LEDTheme,
+)
+
+
+class TestLEDTheme:
+    def test_values(self):
+        assert LEDTheme.NATURE == 0x01
+        assert LEDTheme.PARTY == 0x02
+        assert LEDTheme.SPIRITUAL == 0x03
+        assert LEDTheme.COCKTAIL == 0x04
+        assert LEDTheme.WEATHER == 0x05
+        assert LEDTheme.CANVAS == 0xC1
+
+    def test_display_names(self):
+        assert LEDTheme.NATURE.display_name == "Nature"
+        assert LEDTheme.CANVAS.display_name == "Canvas"
+
+    def test_nature_patterns(self):
+        patterns = LEDTheme.NATURE.patterns
+        assert len(patterns) == 4
+        assert LEDPattern.CAMPFIRE in patterns
+        assert LEDPattern.NORTHERN_LIGHTS in patterns
+        assert LEDPattern.SEA_WAVE in patterns
+        assert LEDPattern.UNIVERSE in patterns
+
+    def test_party_patterns(self):
+        assert len(LEDTheme.PARTY.patterns) == 5
+        assert LEDPattern.RAINBOW in LEDTheme.PARTY.patterns
+
+    def test_spiritual_patterns(self):
+        assert len(LEDTheme.SPIRITUAL.patterns) == 3
+
+    def test_cocktail_patterns(self):
+        assert len(LEDTheme.COCKTAIL.patterns) == 4
+
+    def test_weather_patterns(self):
+        assert len(LEDTheme.WEATHER.patterns) == 5
+
+    def test_canvas_empty(self):
+        assert LEDTheme.CANVAS.patterns == []
+
+    def test_all_patterns_assigned(self):
+        all_patterns = []
+        for theme in LEDTheme:
+            all_patterns.extend(theme.patterns)
+        assert len(all_patterns) == len(LEDPattern)
+
+
+class TestLEDPattern:
+    def test_campfire_value(self):
+        assert LEDPattern.CAMPFIRE == 0x01
+
+    def test_cherry_value(self):
+        assert LEDPattern.CHERRY == 0x16
+
+    def test_display_name(self):
+        assert LEDPattern.NORTHERN_LIGHTS.display_name == "Northern Lights"
+        assert LEDPattern.FRUIT_GIN.display_name == "Fruit Gin"
+
+    def test_theme_mapping(self):
+        assert LEDPattern.CAMPFIRE.theme == LEDTheme.NATURE
+        assert LEDPattern.RAINBOW.theme == LEDTheme.PARTY
+        assert LEDPattern.LAVA.theme == LEDTheme.SPIRITUAL
+        assert LEDPattern.MOJITO.theme == LEDTheme.COCKTAIL
+        assert LEDPattern.THUNDER.theme == LEDTheme.WEATHER
+
+    def test_all_patterns_have_theme(self):
+        for pattern in LEDPattern:
+            assert pattern.theme is not None
+
+
+class TestColorEffect:
+    def test_values(self):
+        assert ColorEffect.STATIC == 0
+        assert ColorEffect.COLOR_LOOP == 1
+
+
+class TestLookups:
+    def test_theme_by_name(self):
+        assert THEME_BY_NAME["nature"] == LEDTheme.NATURE
+        assert THEME_BY_NAME["party"] == LEDTheme.PARTY
+        assert "canvas" not in THEME_BY_NAME
+
+    def test_pattern_by_name(self):
+        assert PATTERN_BY_NAME["campfire"] == LEDPattern.CAMPFIRE
+        assert PATTERN_BY_NAME["northern lights"] == LEDPattern.NORTHERN_LIGHTS
+
+    def test_all_themes_in_lookup(self):
+        # Canvas excluded
+        assert len(THEME_BY_NAME) == 5
+
+    def test_all_patterns_in_lookup(self):
+        assert len(PATTERN_BY_NAME) == len(LEDPattern)