zencontrol-python 0.1.4__tar.gz → 0.1.6__tar.gz

{zencontrol_python-0.1.4/zencontrol_python.egg-info → zencontrol_python-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zencontrol-python
-Version: 0.1.4
+Version: 0.1.6
 Summary: Python implementation of the Zencontrol TPI Advanced protocol for DALI lighting controllers.
 Author: Simon Wright
 License-Expression: MIT
@@ -49,10 +49,12 @@ A practical demonstration is [zencontrol-homeassistant](https://github.com/sjwri
 Beyond basic lighting control, this library supports:
 
 * **Broad command surface** — inhibit, custom fade, step/up/down helpers, colour scene membership queries, EAN/serial, and most related TPI Advanced commands
-* **Object-based entity model** — Optional. Expresses lights, groups, profiles, buttons, motion sensors, and system variables as rich objects with interview/discovery helpers
+* **Object-based entity model** — Optional. Expresses lights, groups, profiles, buttons, motion sensors, absolute inputs, and system variables as rich objects with interview/discovery helpers
 * **UDP transport resilience** — request retries and queue-failure backoff
+* **Event keepalive** — periodic emit-state ping; re-enables TPI events (and unicast target) if a controller reboots while the listener stays up
 * **Multicast controller discovery** — find controllers on the LAN without a preconfigured host
 * **Button events** — discovery of control-device button instances, plus press and long-press event callbacks
+* **Absolute inputs** — discovery of numerical ECD instances (dials/sliders) with 16-bit value-change event callbacks
 * **Event filtering** — configure which TPI events the controller emits
 * **System variables** — labelled SV discovery, read/write, and change events
 * **Profiles** — query, change, and return to the scheduled profile

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/README.md

@@ -15,10 +15,12 @@ A practical demonstration is [zencontrol-homeassistant](https://github.com/sjwri
 Beyond basic lighting control, this library supports:
 
 * **Broad command surface** — inhibit, custom fade, step/up/down helpers, colour scene membership queries, EAN/serial, and most related TPI Advanced commands
-* **Object-based entity model** — Optional. Expresses lights, groups, profiles, buttons, motion sensors, and system variables as rich objects with interview/discovery helpers
+* **Object-based entity model** — Optional. Expresses lights, groups, profiles, buttons, motion sensors, absolute inputs, and system variables as rich objects with interview/discovery helpers
 * **UDP transport resilience** — request retries and queue-failure backoff
+* **Event keepalive** — periodic emit-state ping; re-enables TPI events (and unicast target) if a controller reboots while the listener stays up
 * **Multicast controller discovery** — find controllers on the LAN without a preconfigured host
 * **Button events** — discovery of control-device button instances, plus press and long-press event callbacks
+* **Absolute inputs** — discovery of numerical ECD instances (dials/sliders) with 16-bit value-change event callbacks
 * **Event filtering** — configure which TPI events the controller emits
 * **System variables** — labelled SV discovery, read/write, and change events
 * **Profiles** — query, change, and return to the scheduled profile

zencontrol_python-0.1.6/tests/test_absolute_input.py

@@ -0,0 +1,96 @@
+"""Unit tests for ZenAbsoluteInput discovery and events."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock
+
+import pytest
+
+from zencontrol.api.models import ZenAddress, ZenInstance
+from zencontrol.api.types import ZenAddressType, ZenInstanceType
+from zencontrol.interface.interface import ZenAbsoluteInput, ZenControl
+
+
+def _ecd_instance(zen: ZenControl, *, number: int = 0, inst: int = 1) -> ZenInstance:
+    ctrl = zen.add_controller(
+        id=1, name="house", label="House", host="127.0.0.1", port=5108
+    )
+    addr = ZenAddress(controller=ctrl, type=ZenAddressType.ECD, number=number)
+    return ZenInstance(address=addr, type=ZenInstanceType.ABSOLUTE_INPUT, number=inst)
+
+
+@pytest.mark.asyncio
+async def test_absolute_input_event_parses_16bit_value() -> None:
+    zen = ZenControl()
+    instance = _ecd_instance(zen)
+    changes: list[tuple[ZenAbsoluteInput, int]] = []
+
+    async def on_change(absolute_input: ZenAbsoluteInput, value: int) -> None:
+        changes.append((absolute_input, value))
+
+    zen.absolute_input_change = on_change
+    absolute = ZenAbsoluteInput(protocol=zen.protocol, instance=instance)
+    assert absolute.interview_hydrate(
+        {"serial": "1", "label": "Panel", "instance_label": "Dial"}
+    )
+
+    await zen.absolute_input_event(instance, bytes([1, 0x12, 0x34]))
+    assert absolute.value == 0x1234
+    assert changes == [(absolute, 0x1234)]
+
+    await zen.absolute_input_event(instance, bytes([1, 0x12, 0x34]))
+    assert changes == [(absolute, 0x1234)]
+
+    await zen.absolute_input_event(instance, bytes([1, 0x00, 0x01]))
+    assert absolute.value == 1
+    assert changes[-1] == (absolute, 1)
+
+
+@pytest.mark.asyncio
+async def test_absolute_input_event_ignores_short_payload() -> None:
+    zen = ZenControl()
+    instance = _ecd_instance(zen)
+    absolute = ZenAbsoluteInput(protocol=zen.protocol, instance=instance)
+    await zen.absolute_input_event(instance, bytes([1]))
+    assert absolute.value is None
+
+
+@pytest.mark.asyncio
+async def test_get_absolute_inputs_filters_instance_type() -> None:
+    zen = ZenControl()
+    ctrl = zen.add_controller(
+        id=1, name="house", label="House", host="127.0.0.1", port=5108
+    )
+    addr = ZenAddress(controller=ctrl, type=ZenAddressType.ECD, number=2)
+    abs_inst = ZenInstance(
+        address=addr, type=ZenInstanceType.ABSOLUTE_INPUT, number=0
+    )
+    btn_inst = ZenInstance(
+        address=addr, type=ZenInstanceType.PUSH_BUTTON, number=1
+    )
+
+    zen._get_addresses_with_instances = AsyncMock(return_value=[addr])  # noqa: SLF001
+    zen.protocol.query_instances_by_address = AsyncMock(
+        return_value=[abs_inst, btn_inst]
+    )
+    zen.protocol.query_dali_device_label = AsyncMock(return_value="Wall")
+    zen.protocol.query_dali_serial = AsyncMock(return_value="ABC")
+    zen.protocol.query_dali_instance_label = AsyncMock(return_value="Slider")
+
+    found = await zen.get_absolute_inputs(controller=ctrl)
+    assert len(found) == 1
+    item = next(iter(found))
+    assert item.instance.type == ZenInstanceType.ABSOLUTE_INPUT
+    assert item.label == "Wall"
+    assert item.instance_label == "Slider"
+    assert item in ctrl.absolute_inputs
+
+
+@pytest.mark.asyncio
+async def test_absolute_input_singleton_per_protocol() -> None:
+    zen = ZenControl()
+    instance = _ecd_instance(zen)
+    a = ZenAbsoluteInput(protocol=zen.protocol, instance=instance)
+    b = ZenAbsoluteInput(protocol=zen.protocol, instance=instance)
+    assert a is b
+    assert "house 0 1" in zen.protocol.entity_registry.absolute_inputs

zencontrol_python-0.1.6/tests/test_event_keepalive.py

@@ -0,0 +1,174 @@
+"""Unit tests for TPI event emit keepalive / re-assert."""
+
+from __future__ import annotations
+
+import asyncio
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from zencontrol.api.types import ZenEventMode
+from zencontrol.interface.interface import ZenControl
+
+
+class _BlockingListener:
+    def __init__(self) -> None:
+        self.listen_port = 6969
+
+    async def events(self):
+        try:
+            while True:
+                await asyncio.sleep(3600)
+                yield  # pragma: no cover
+        except asyncio.CancelledError:
+            raise
+
+    async def close(self):
+        return None
+
+
+def _controller(name: str = "ctrl") -> SimpleNamespace:
+    return SimpleNamespace(name=name, filtering=False, mac="AA:BB:CC:DD:EE:01")
+
+
+@pytest.mark.asyncio
+async def test_assert_reconfigures_when_emit_disabled() -> None:
+    zen = ZenControl()
+    zen.protocol.event_listener = object()  # pretend listener is up
+    ctrl = _controller()
+    ctrl.is_controller_ready = AsyncMock(return_value=True)
+    zen.controllers = [ctrl]  # type: ignore[list-item]
+
+    zen.protocol.query_tpi_event_unicast_address = AsyncMock(return_value=None)
+    zen.protocol.query_tpi_event_emit_state = AsyncMock(return_value=False)
+    zen.configure_controller_events = AsyncMock(return_value=True)
+
+    assert await zen.assert_controller_events(ctrl) is True  # type: ignore[arg-type]
+    zen.configure_controller_events.assert_awaited_once_with(ctrl)
+
+
+@pytest.mark.asyncio
+async def test_assert_marks_unreachable_when_reassert_fails() -> None:
+    zen = ZenControl()
+    zen.protocol.event_listener = object()
+    ctrl = _controller()
+    ctrl.is_controller_ready = AsyncMock(return_value=True)
+    zen.protocol.query_tpi_event_unicast_address = AsyncMock(return_value=None)
+    zen.protocol.query_tpi_event_emit_state = AsyncMock(return_value=False)
+    zen.configure_controller_events = AsyncMock(return_value=False)
+    status_cb = AsyncMock()
+    zen.controller_status_change = status_cb
+
+    assert await zen.assert_controller_events(ctrl) is False  # type: ignore[arg-type]
+    status_cb.assert_awaited_once_with(ctrl, "unreachable")
+
+
+@pytest.mark.asyncio
+async def test_assert_defers_while_controller_not_ready() -> None:
+    zen = ZenControl()
+    zen.protocol.event_listener = object()
+    ctrl = _controller()
+    ctrl.is_controller_ready = AsyncMock(return_value=False)
+    zen.configure_controller_events = AsyncMock()
+    zen.protocol.query_tpi_event_unicast_address = AsyncMock()
+    status_cb = AsyncMock()
+    zen.controller_status_change = status_cb
+
+    assert await zen.assert_controller_events(ctrl) is True  # type: ignore[arg-type]
+    zen.configure_controller_events.assert_not_awaited()
+    zen.protocol.query_tpi_event_unicast_address.assert_not_awaited()
+    status_cb.assert_awaited_once_with(ctrl, "starting")
+
+
+@pytest.mark.asyncio
+async def test_assert_noop_when_emit_enabled() -> None:
+    zen = ZenControl()
+    zen.protocol.event_listener = object()
+    ctrl = _controller()
+    ctrl.is_controller_ready = AsyncMock(return_value=True)
+
+    zen.protocol.query_tpi_event_unicast_address = AsyncMock(
+        return_value={
+            "mode": ZenEventMode(enabled=True, unicast=False, multicast=True),
+            "port": 0,
+            "ip": "0.0.0.0",
+        }
+    )
+    zen.configure_controller_events = AsyncMock()
+
+    assert await zen.assert_controller_events(ctrl) is True  # type: ignore[arg-type]
+    zen.configure_controller_events.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_assert_reconfigures_on_unicast_target_mismatch() -> None:
+    zen = ZenControl(unicast=True)
+    zen.protocol.event_listener = object()
+    zen.protocol.local_ip = "192.168.1.10"
+    zen.protocol.listen_port = 6970
+    ctrl = _controller()
+    ctrl.is_controller_ready = AsyncMock(return_value=True)
+
+    zen.protocol.query_tpi_event_unicast_address = AsyncMock(
+        return_value={
+            "mode": ZenEventMode(enabled=True, unicast=True, multicast=False),
+            "port": 6970,
+            "ip": "192.168.1.99",  # stale target after HA IP change / reboot
+        }
+    )
+    zen.configure_controller_events = AsyncMock(return_value=True)
+
+    assert await zen.assert_controller_events(ctrl) is True  # type: ignore[arg-type]
+    zen.configure_controller_events.assert_awaited_once_with(ctrl)
+
+
+@pytest.mark.asyncio
+async def test_assert_returns_false_when_ping_fails() -> None:
+    zen = ZenControl()
+    zen.protocol.event_listener = object()
+    ctrl = _controller()
+    ctrl.is_controller_ready = AsyncMock(return_value=None)
+    zen.configure_controller_events = AsyncMock()
+
+    assert await zen.assert_controller_events(ctrl) is False  # type: ignore[arg-type]
+    zen.configure_controller_events.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_keepalive_loop_reasserts_and_stops_cleanly() -> None:
+    zen = ZenControl()
+    zen.event_keepalive_interval = 0.05
+    zen.reconnect_min_delay = 0.01
+    ctrl = _controller()
+    zen.add_controller(
+        id=1,
+        name=ctrl.name,
+        label="Controller",
+        host="127.0.0.1",
+        mac=ctrl.mac,
+    )
+
+    configure = AsyncMock()
+    zen.configure_controller_events = configure
+    zen.protocol.query_tpi_event_unicast_address = AsyncMock(return_value=None)
+    zen.protocol.query_tpi_event_emit_state = AsyncMock(return_value=False)
+    zen.protocol.query_controller_startup_complete = AsyncMock(return_value=True)
+    # start_event_monitoring configures controllers itself; stub the UDP path.
+    zen.protocol.set_tpi_event_unicast_address = AsyncMock()
+    zen.protocol.tpi_event_emit = AsyncMock(return_value=True)
+
+    with patch(
+        "zencontrol.api.protocol.ZenListener.create",
+        new=AsyncMock(return_value=_BlockingListener()),
+    ):
+        await zen.start()
+        for _ in range(40):
+            if configure.await_count >= 1:
+                break
+            await asyncio.sleep(0.05)
+        else:
+            pytest.fail("keepalive did not re-assert events")
+
+        await zen.stop()
+        assert zen._keepalive_task is None or zen._keepalive_task.done()

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/tests/test_sim_events.py

@@ -158,6 +158,28 @@ async def test_button_hold_and_occupancy_inject(live_sim):
     )
 
 
+@pytest.mark.asyncio
+async def test_absolute_input_inject(live_sim):
+    p = live_sim.protocol
+    events: list[tuple[int, int, bytes]] = []
+
+    async def on_absolute(*, instance, payload):
+        events.append((instance.address.number, instance.number, bytes(payload)))
+
+    p.set_callbacks(absolute_input_callback=on_absolute)
+    await p.start_event_monitoring()
+
+    live_sim.sim.inject_absolute_input(13, 0, 0xABCD)
+    await wait_until(
+        lambda: any(
+            ecd == 13 and inst == 0 and payload == bytes([0, 0xAB, 0xCD])
+            for ecd, inst, payload in events
+        ),
+        message="expected absolute-input inject event for ECD 13",
+    )
+    assert live_sim.world.instance(13, 0).value == 0xABCD
+
+
 @pytest.mark.asyncio
 async def test_inject_level_scene_colour_profile_events(live_sim):
     from zencontrol_simulator.world import Colour

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/tests/test_sim_interface.py

@@ -22,6 +22,7 @@ async def test_interview_discovers_entities(live_zen):
     lights = await zen.get_lights()
     groups = await zen.get_groups()
     buttons = await zen.get_buttons()
+    absolute_inputs = await zen.get_absolute_inputs()
     sensors = await zen.get_motion_sensors()
     profiles = await zen.get_profiles()
     sysvars = await zen.get_system_variables(give_up_after=5)
@@ -29,6 +30,7 @@ async def test_interview_discovers_entities(live_zen):
     assert len(lights) == 12
     assert len(groups) == 6
     assert len(buttons) >= 9
+    assert len(absolute_inputs) >= 1
     assert len(sensors) >= 2
     assert len(profiles) == 3
     assert len(sysvars) >= 2
@@ -42,6 +44,13 @@ async def test_interview_discovers_entities(live_zen):
     assert any(getattr(s, "instance_label", None) == "Motion" for s in sensors)
     assert any(getattr(b, "label", None) == "Living Room Switch" for b in buttons)
     assert any(getattr(s, "label", None) == "Porch Sensor" for s in sensors)
+    slider = next(
+        a
+        for a in absolute_inputs
+        if a.instance.address.number == 13 and a.instance.number == 0
+    )
+    assert slider.instance_label == "Slider"
+    assert slider.value is None
 
     # World state still matches what we interviewed
     assert live_sim.world.lights[0].label == "Living Room Ceiling"
@@ -121,6 +130,7 @@ async def test_start_receives_injected_and_control_events(live_zen):
     button_events: list = []
     hold_events: list = []
     motion_events: list = []
+    absolute_events: list = []
     profile_events: list = []
     sysvar_events: list = []
     colour_events: list = []
@@ -136,6 +146,9 @@ async def test_start_receives_injected_and_control_events(live_zen):
     async def on_motion(sensor, occupied):
         motion_events.append((sensor, occupied))
 
+    async def on_absolute(absolute_input, value):
+        absolute_events.append((absolute_input, value))
+
     async def on_profile(profile):
         profile_events.append(profile)
 
@@ -153,6 +166,7 @@ async def test_start_receives_injected_and_control_events(live_zen):
     zen.button_press = on_button
     zen.button_long_press = on_hold
     zen.motion_event = on_motion
+    zen.absolute_input_change = on_absolute
     zen.profile_change = on_profile
     zen.system_variable_change = on_sysvar
     zen.light_change = on_light
@@ -201,14 +215,18 @@ async def test_start_receives_injected_and_control_events(live_zen):
     live_sim.sim.inject_button_hold(0, 1)
     live_sim.sim.inject_button_hold(0, 1)
     live_sim.sim.inject_occupancy(0, 2, occupied=True)
+    live_sim.sim.inject_absolute_input(13, 0, 0x1234)
     await wait_until(
         lambda: (
             len(button_events) >= 1
             and len(hold_events) >= 1
             and len(motion_events) >= 1
+            and any(value == 0x1234 for _, value in absolute_events)
         ),
-        message="expected injected button/hold/motion callbacks",
+        message="expected injected button/hold/motion/absolute-input callbacks",
     )
+    assert absolute_events[0][0].value == 0x1234
+    assert absolute_events[0][0].instance.address.number == 13
 
     await zen.stop()
 
@@ -226,19 +244,12 @@ async def test_rgb_and_xy_via_interface(live_zen):
     assert live_sim.world.lights[2].colour.r == 1
     assert live_sim.world.lights[2].level == 100
 
-    assert lights[3].features.get("temperature") is False or lights[3].features.get(
-        "RGB"
-    ) is False
+    assert lights[3].features.get("XY") is True
     xy = ZenColour(type=ZenColourType.XY, x=15000, y=16000)
-    # XY spotlight may expose via colour support rather than RGB feature flag
-    if lights[3].supports_colour(xy):
-        assert await lights[3].set(colour=xy, level=90) is True
-        assert live_sim.world.lights[3].colour.x == 15000
-        assert live_sim.world.lights[3].level == 90
-    else:
-        # Fall back to protocol path still reachable through interface protocol
-        assert await zen.protocol.dali_colour(lights[3].address, xy, level=90) is True
-        assert live_sim.world.lights[3].colour.x == 15000
+    assert lights[3].supports_colour(xy) is True
+    assert await lights[3].set(colour=xy, level=90) is True
+    assert live_sim.world.lights[3].colour.x == 15000
+    assert live_sim.world.lights[3].level == 90
 
 
 @pytest.mark.asyncio

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/tests/test_sim_protocol.py

@@ -230,6 +230,41 @@ async def test_injected_button_and_occupancy_events(live_sim):
     )
 
 
+@pytest.mark.asyncio
+async def test_injected_absolute_input_event(live_sim):
+    p = live_sim.protocol
+    events: list[tuple[int, int, bytes]] = []
+
+    async def on_absolute(*, instance, payload):
+        events.append((instance.address.number, instance.number, bytes(payload)))
+
+    p.set_callbacks(absolute_input_callback=on_absolute)
+    await p.start_event_monitoring()
+    live_sim.sim.inject_absolute_input(13, 0, 4660)
+    await wait_until(
+        lambda: any(
+            ecd == 13 and inst == 0 and payload == bytes([0, 0x12, 0x34])
+            for ecd, inst, payload in events
+        ),
+        message="expected injected absolute-input event",
+    )
+
+
+@pytest.mark.asyncio
+async def test_query_absolute_input_instance(live_sim):
+    """Demo ECD 13 exposes a discoverable absolute_input instance."""
+    from zencontrol import ZenAddress, ZenAddressType, ZenInstanceType
+
+    p = live_sim.protocol
+    c = live_sim.controller
+    addr = ZenAddress(controller=c, type=ZenAddressType.ECD, number=13)
+    instances = await p.query_instances_by_address(address=addr)
+    assert any(
+        inst.number == 0 and inst.type == ZenInstanceType.ABSOLUTE_INPUT
+        for inst in instances
+    )
+
+
 @pytest.mark.asyncio
 async def test_timeout_when_simulator_stopped(live_sim):
     from zencontrol import ZenTimeoutError

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/zencontrol/__init__.py

@@ -40,6 +40,7 @@ from .interface import (
     ZenLight,
     ZenGroup,
     ZenButton,
+    ZenAbsoluteInput,
     ZenMotionSensor,
     ZenSystemVariable,
 )
@@ -58,7 +59,7 @@ from .exceptions import ZenError, ZenTimeoutError, ZenResponseError, ZenConnecti
 # Utilities
 from .utils import run_with_keyboard_interrupt
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"
 __author__ = "Simon Wright"
 
 # Public API - these are the main classes users should import
@@ -72,6 +73,7 @@ __all__ = [
     "ZenLight",
     "ZenGroup",
     "ZenButton",
+    "ZenAbsoluteInput",
     "ZenMotionSensor",
     "ZenSystemVariable",
     

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/zencontrol/api/protocol.py

@@ -57,6 +57,7 @@ class ZenCallbacks:
         self.light_change: Callable[..., Awaitable[None]] | None = None
         self.button_press: Callable[..., Awaitable[None]] | None = None
         self.button_long_press: Callable[..., Awaitable[None]] | None = None
+        self.absolute_input_change: Callable[..., Awaitable[None]] | None = None
         self.motion_event: Callable[..., Awaitable[None]] | None = None
         self.system_variable_change: Callable[..., Awaitable[None]] | None = None
         self.controller_discovered: Callable[[DiscoveredController], Awaitable[None]] | None = None
@@ -75,6 +76,7 @@ class EntityRegistry:
         self.lights: dict[str, Any] = {}
         self.groups: dict[str, Any] = {}
         self.buttons: dict[str, Any] = {}
+        self.absolute_inputs: dict[str, Any] = {}
         self.motion_sensors: dict[str, Any] = {}
         self.system_variables: dict[str, Any] = {}
 
@@ -84,6 +86,7 @@ class EntityRegistry:
         self.lights.clear()
         self.groups.clear()
         self.buttons.clear()
+        self.absolute_inputs.clear()
         self.motion_sensors.clear()
         self.system_variables.clear()
 
@@ -96,6 +99,7 @@ class EntityRegistry:
             self.lights,
             self.groups,
             self.buttons,
+            self.absolute_inputs,
             self.motion_sensors,
             self.system_variables,
         ):
@@ -873,7 +877,7 @@ class ZenProtocol:
         min_payload = {
             ZenEventCode.BUTTON_PRESS: 1,
             ZenEventCode.BUTTON_HOLD: 1,
-            ZenEventCode.ABSOLUTE_INPUT: 1,
+            ZenEventCode.ABSOLUTE_INPUT: 3,
             ZenEventCode.LEVEL_CHANGE: 1,
             ZenEventCode.LEVEL_CHANGE_V2: 2,
             ZenEventCode.GROUP_LEVEL_CHANGE: 1,
@@ -921,10 +925,10 @@ class ZenProtocol:
                     await self.button_hold_callback(instance=instance, payload=payload)
 
             case ZenEventCode.ABSOLUTE_INPUT:
+                value = (payload[1] << 8) | payload[2]
                 if self.print_traffic: 
                     print(Fore.MAGENTA + f"{typecast.upper()} {ip_address}:" +
-                        Fore.CYAN + f" Absolute {target-64}" +
-                        Style.DIM + f" [{' '.join(f'0x{b:02X}' for b in payload)}]" +
+                        Fore.CYAN + f" Absolute {target-64}.{payload[0]} = {value}" +
                         Style.RESET_ALL)
                 if self.absolute_input_callback:
                     address = self._ecd_address_from_target(controller, target)

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/zencontrol/api/types.py

@@ -203,3 +203,7 @@ class Const:
     RECONNECT_MIN_DELAY = 1.0
     RECONNECT_MAX_DELAY = 30.0
     RECONNECT_HEALTHY_SECONDS = 60.0
+    
+    # Periodic emit-state check — controllers that reboot while our listener
+    # stays up lose TPI event config until we re-assert it.
+    EVENT_KEEPALIVE_INTERVAL = 30.0

{zencontrol_python-0.1.4 → zencontrol_python-0.1.6}/zencontrol/interface/__init__.py

@@ -14,6 +14,7 @@ from .interface import (
     ZenLight,
     ZenGroup,
     ZenButton,
+    ZenAbsoluteInput,
     ZenMotionSensor,
     ZenSystemVariable,
 )
@@ -28,6 +29,7 @@ __all__ = [
     "ZenLight",
     "ZenGroup",
     "ZenButton",
+    "ZenAbsoluteInput",
     "ZenMotionSensor",
     "ZenSystemVariable",
 ]