zencontrol-python 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

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/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/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/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",
 ]

zencontrol/interface/interface.py

@@ -4,7 +4,7 @@ import asyncio
 import json
 import time
 import logging
-from typing import Any, cast, Self
+from typing import Any, Literal, cast, Self
 from collections.abc import Coroutine, Callable, Awaitable
 
 from ..api import ZenProtocol, ZenController as SuperZenController, ZenAddress, ZenInstance, ZenAddressType, ZenColour, ZenColourType, ZenInstanceType
@@ -140,10 +140,13 @@ class ZenControl:
         self.protocol.callbacks = ZenCallbacks()
         self._stopping = False
         self._supervisor_task: asyncio.Task[None] | None = None
+        self._keepalive_task: asyncio.Task[None] | None = None
         self._first_connected = asyncio.Event()
+        self._controller_status_change: CallbackControllerStatusChange | None = None
         self.reconnect_min_delay = Const.RECONNECT_MIN_DELAY
         self.reconnect_max_delay = Const.RECONNECT_MAX_DELAY
         self.reconnect_healthy_seconds = Const.RECONNECT_HEALTHY_SECONDS
+        self.event_keepalive_interval = Const.EVENT_KEEPALIVE_INTERVAL
 
     async def __aenter__(self) -> Self:
         return self
@@ -207,7 +210,14 @@ class ZenControl:
     @button_long_press.setter
     def button_long_press(self, func: CallbackButtonLongPress | None) -> None:
         self.protocol.callbacks.button_long_press = func
-    
+
+    @property
+    def absolute_input_change(self) -> CallbackAbsoluteInputChange | None:
+        return self.protocol.callbacks.absolute_input_change
+    @absolute_input_change.setter
+    def absolute_input_change(self, func: CallbackAbsoluteInputChange | None) -> None:
+        self.protocol.callbacks.absolute_input_change = func
+
     @property
     def motion_event(self) -> CallbackMotionEvent | None:
         return self.protocol.callbacks.motion_event
@@ -229,6 +239,15 @@ class ZenControl:
     def controller_discovered(self, func: CallbackControllerDiscovered | None) -> None:
         self.protocol.callbacks.controller_discovered = func
 
+    @property
+    def controller_status_change(self) -> CallbackControllerStatusChange | None:
+        return self._controller_status_change
+    @controller_status_change.setter
+    def controller_status_change(
+        self, func: CallbackControllerStatusChange | None
+    ) -> None:
+        self._controller_status_change = func
+
     @property
     def discovered_controllers(self) -> list[DiscoveredController]:
         """Controllers identified from multicast but not yet registered."""
@@ -266,30 +285,116 @@ class ZenControl:
             except Exception:
                 pass
 
-    async def configure_controller_events(self, controller: ZenController) -> None:
+    async def configure_controller_events(self, controller: ZenController) -> bool:
         """Enable TPI event emit for one controller using this client's listen mode.
 
         Call after ``add_controller`` when event monitoring is already running so a
-        newly attached controller joins the shared listener.
+        newly attached controller joins the shared listener. Returns True when the
+        emit-enable command succeeds.
         """
         if self.protocol.event_listener is None:
-            return
+            return False
         unicast = self.protocol.unicast
         await self.protocol.set_tpi_event_unicast_address(
             controller,
             ipaddr=self.protocol.local_ip if unicast else None,
             port=self.protocol.listen_port if unicast else None,
         )
-        await self.protocol.tpi_event_emit(
-            controller,
-            ZenEventMode(
-                enabled=True,
-                filtering=controller.filtering,
-                unicast=unicast,
-                multicast=not unicast,
-            ),
+        return bool(
+            await self.protocol.tpi_event_emit(
+                controller,
+                ZenEventMode(
+                    enabled=True,
+                    filtering=controller.filtering,
+                    unicast=unicast,
+                    multicast=not unicast,
+                ),
+            )
         )
 
+    async def assert_controller_events(self, controller: ZenController) -> bool:
+        """Ping event emit state and re-assert config if the controller lost it.
+
+        Controllers that reboot while our listener stays up typically come back
+        with events disabled (or with a stale unicast target). Returns True when
+        the controller is reachable and events are confirmed/enabled, False when
+        the ping timed out / failed or re-assert could not enable emit.
+
+        Never re-asserts while ``is_controller_ready()`` is false — the startup
+        sequence can take several minutes after a reboot.
+        """
+        if self.protocol.event_listener is None:
+            return False
+
+        ready = await controller.is_controller_ready()
+        if ready is None:
+            self.logger.debug(
+                "No response from %s during event keepalive ping",
+                controller.name,
+            )
+            await self._notify_controller_status(controller, "unreachable")
+            return False
+        if ready is not True:
+            self.logger.debug(
+                "Controller %s still starting — deferring event re-assert",
+                controller.name,
+            )
+            await self._notify_controller_status(controller, "starting")
+            return True
+
+        unicast = self.protocol.unicast
+        needs_reassert = False
+        info = await self.protocol.query_tpi_event_unicast_address(controller)
+        if info is not None:
+            mode = info["mode"]
+            if not mode.enabled or bool(mode.unicast) != unicast:
+                needs_reassert = True
+            elif unicast and (
+                info.get("port") != self.protocol.listen_port
+                or info.get("ip") != self.protocol.local_ip
+            ):
+                needs_reassert = True
+        else:
+            enabled = await self.protocol.query_tpi_event_emit_state(controller)
+            if enabled is None:
+                self.logger.debug(
+                    "No response from %s during event keepalive ping",
+                    controller.name,
+                )
+                await self._notify_controller_status(controller, "unreachable")
+                return False
+            needs_reassert = not enabled
+
+        if needs_reassert:
+            self.logger.info(
+                "Controller %s TPI events not correctly enabled — re-asserting",
+                controller.name,
+            )
+            if not await self.configure_controller_events(controller):
+                self.logger.warning(
+                    "Failed to re-assert TPI events for %s",
+                    controller.name,
+                )
+                await self._notify_controller_status(controller, "unreachable")
+                return False
+        await self._notify_controller_status(controller, "online")
+        return True
+
+    async def _notify_controller_status(
+        self, controller: ZenController, status: ControllerRuntimeStatus
+    ) -> None:
+        """Notify listeners of online / starting / unreachable."""
+        if not callable(self._controller_status_change):
+            return
+        try:
+            await self._controller_status_change(controller, status)
+        except Exception as err:
+            self.logger.debug(
+                "controller_status_change error for %s: %s",
+                controller.name,
+                err,
+            )
+
     async def discover(self, timeout: float = 5.0) -> list[DiscoveredController]:
         """Listen for multicast and return controllers identified within ``timeout`` seconds.
 
@@ -334,6 +439,8 @@ class ZenControl:
         )
         if self._supervisor_task is None or self._supervisor_task.done():
             self._supervisor_task = asyncio.create_task(self._event_monitor_supervisor())
+        if self._keepalive_task is None or self._keepalive_task.done():
+            self._keepalive_task = asyncio.create_task(self._event_keepalive_loop())
         try:
             await asyncio.wait_for(
                 self._first_connected.wait(),
@@ -351,7 +458,7 @@ class ZenControl:
         was_running = bool(
             self.protocol.event_task and not self.protocol.event_task.done()
         )
-        await self._cancel_supervisor()
+        await self._cancel_background_tasks()
         await self.protocol.stop_event_monitoring()
         if was_running:
             await self.protocol.notify_disconnect()
@@ -362,15 +469,19 @@ class ZenControl:
         was_running = bool(
             self.protocol.event_task and not self.protocol.event_task.done()
         )
-        await self._cancel_supervisor()
+        await self._cancel_background_tasks()
         await self.protocol.aclose()
         if was_running:
             await self.protocol.notify_disconnect()
         self.clear_entity_caches()
 
-    async def _cancel_supervisor(self) -> None:
-        task = self._supervisor_task
-        self._supervisor_task = None
+    async def _cancel_background_tasks(self) -> None:
+        await self._cancel_task("_supervisor_task")
+        await self._cancel_task("_keepalive_task")
+
+    async def _cancel_task(self, attr: str) -> None:
+        task: asyncio.Task[None] | None = getattr(self, attr)
+        setattr(self, attr, None)
         if task is None or task.done():
             return
         task.cancel()
@@ -448,6 +559,33 @@ class ZenControl:
             except Exception:
                 pass
 
+    async def _event_keepalive_loop(self) -> None:
+        """Periodically ping controllers and re-enable TPI events if needed."""
+        try:
+            await self._first_connected.wait()
+        except asyncio.CancelledError:
+            raise
+        while not self._stopping:
+            try:
+                await asyncio.sleep(self.event_keepalive_interval)
+            except asyncio.CancelledError:
+                raise
+            if self._stopping or self.protocol.event_listener is None:
+                continue
+            for controller in list(self.controllers):
+                if self._stopping:
+                    return
+                try:
+                    await self.assert_controller_events(controller)
+                except asyncio.CancelledError:
+                    raise
+                except Exception as err:
+                    self.logger.debug(
+                        "Event keepalive failed for %s: %s",
+                        controller.name,
+                        err,
+                    )
+
     async def _protocol_disconnect_event(self) -> None:
         """Forward protocol-level disconnect to the high-level on_disconnect hook."""
         if callable(self.protocol.callbacks.on_disconnect):
@@ -464,7 +602,9 @@ class ZenControl:
         await ZenButton(protocol=self.protocol, instance=instance)._event_received(held=True)
 
     async def absolute_input_event(self, instance: ZenInstance, payload: bytes) -> None:
-        pass
+        await ZenAbsoluteInput(protocol=self.protocol, instance=instance)._event_received(
+            payload
+        )
 
     async def is_occupied_event(self, instance: ZenInstance, payload: bytes) -> None:
         await ZenMotionSensor(protocol=self.protocol, instance=instance)._event_received()
@@ -617,6 +757,24 @@ class ZenControl:
                         motion_sensors.add(motion_sensor)
         return motion_sensors
 
+    async def get_absolute_inputs(
+        self, controller: ZenController | None = None
+    ) -> set[ZenAbsoluteInput]:
+        """Return absolute (numerical) ECD instances (optionally for one controller)."""
+        absolute_inputs: set[ZenAbsoluteInput] = set()
+        controllers = [controller] if controller else self.controllers
+        for ctrl in controllers:
+            addresses = await self._get_addresses_with_instances(ctrl)
+            for address in addresses:
+                instances = await self.protocol.query_instances_by_address(address=address)
+                for instance in instances:
+                    if instance.type == ZenInstanceType.ABSOLUTE_INPUT:
+                        absolute_input = await ZenAbsoluteInput.create(
+                            protocol=self.protocol, instance=instance
+                        )
+                        absolute_inputs.add(absolute_input)
+        return absolute_inputs
+
     async def get_system_variables(
         self,
         give_up_after: int = 10,
@@ -654,6 +812,7 @@ class ZenController(SuperZenController):
     lights: set[ZenLight] = set()
     groups: set[ZenGroup] = set()
     buttons: set[ZenButton] = set()
+    absolute_inputs: set[ZenAbsoluteInput] = set()
     motion_sensors: set[ZenMotionSensor] = set()
     sysvars: set[ZenSystemVariable] = set()
     client_data: dict[str, Any] = {}
@@ -716,6 +875,7 @@ class ZenController(SuperZenController):
         self.lights = set()
         self.groups = set()
         self.buttons = set()
+        self.absolute_inputs = set()
         self.motion_sensors = set()
         self.sysvars = set()
         self.client_data = {}
@@ -839,6 +999,7 @@ class ZenLight:
         "RGB": False,
         "RGBW": False,
         "RGBWW": False,
+        "XY": False,
     }
     properties: dict[str, int | None] = {
         "min_kelvin": Const.DEFAULT_WARMEST_TEMP,
@@ -894,6 +1055,7 @@ class ZenLight:
             "RGB": False,
             "RGBW": False,
             "RGBWW": False,
+            "XY": False,
         }
         self.properties = {
             "min_kelvin": Const.DEFAULT_WARMEST_TEMP,
@@ -963,6 +1125,10 @@ class ZenLight:
             # If cgtype contains 8, it supports some kind of colour
             if 8 in self.cgtype:
                 cgtype = await self.protocol.query_dali_colour_features(self.address)
+                # XY is independent of TC/RGBWAF; a fixture may support more than one.
+                if cgtype and cgtype.get("supports_xy", False) is True:
+                    self.features["brightness"] = True
+                    self.features["XY"] = True
                 if cgtype and cgtype.get("supports_tunable", False) is True:
                     self.features["brightness"] = True
                     self.features["temperature"] = True
@@ -1006,7 +1172,13 @@ class ZenLight:
         refreshed_scene = None
         if await self.protocol.dali_query_last_scene_is_current(self.address):
             refreshed_scene = await self.protocol.dali_query_last_scene(self.address)
-        if self.features["temperature"] or self.features["RGB"] or self.features["RGBW"] or self.features["RGBWW"]:
+        if (
+            self.features.get("temperature")
+            or self.features.get("RGB")
+            or self.features.get("RGBW")
+            or self.features.get("RGBWW")
+            or self.features.get("XY")
+        ):
             refreshed_colour = await self.protocol.query_dali_colour(self.address)
         
         if verifying:
@@ -1144,10 +1316,11 @@ class ZenLight:
             colour_type = colour
         else:
             return False;
-        if (colour_type == ZenColourType.TC and self.features["temperature"]) or \
-            (colour_type == ZenColourType.RGBWAF and self.features["RGB"]) or \
-            (colour_type == ZenColourType.RGBWAF and self.features["RGBW"]) or \
-            (colour_type == ZenColourType.RGBWAF and self.features["RGBWW"]):
+        if (colour_type == ZenColourType.TC and self.features.get("temperature")) or \
+            (colour_type == ZenColourType.RGBWAF and self.features.get("RGB")) or \
+            (colour_type == ZenColourType.RGBWAF and self.features.get("RGBW")) or \
+            (colour_type == ZenColourType.RGBWAF and self.features.get("RGBWW")) or \
+            (colour_type == ZenColourType.XY and self.features.get("XY")):
             return True
         return False
     # -----------------------------------------------------------------------------------------
@@ -1403,6 +1576,110 @@ class ZenButton:
                     await self.protocol.callbacks.button_long_press(button=self)
 
 
+class ZenAbsoluteInput:
+    """DALI ECD absolute (numerical) input instance — dials, sliders, etc.
+
+    Controllers emit value-change events only; TPI has no query/set command for
+    the current value, so ``value`` stays ``None`` until the first event.
+    Payload matches ``_protocol.txt``: ``[instance, value_hi, value_lo]``.
+    """
+
+    protocol: ZenProtocol
+    instance: ZenInstance
+    serial: (int | str) | None = None
+    label: str | None = None
+    instance_label: str | None = None
+    _value: int | None = None
+    client_data: dict[str, Any] = {}
+
+    def __new__(cls, protocol: ZenProtocol, instance: ZenInstance) -> ZenAbsoluteInput:
+        compound_id = f"{instance.address.controller.name} {instance.address.number} {instance.number}"
+        registry = protocol.entity_registry.absolute_inputs
+        if compound_id not in registry:
+            inst = super().__new__(cls)
+            registry[compound_id] = inst
+            inst.protocol = protocol
+            inst.instance = instance
+            inst._reset()
+        return registry[compound_id]
+
+    def __init__(self, protocol: ZenProtocol, instance: ZenInstance) -> None:
+        self.protocol = protocol
+        self.instance = instance
+
+    @classmethod
+    async def create(cls, protocol: ZenProtocol, instance: ZenInstance) -> ZenAbsoluteInput:
+        """Async factory method for ZenAbsoluteInput."""
+        absolute_input = cls(protocol, instance)
+        await absolute_input.interview()
+        return absolute_input
+
+    def __repr__(self) -> str:
+        return (
+            f"ZenAbsoluteInput<{self.instance.address.controller.name} "
+            f"ecd {self.instance.address.number} inst {self.instance.number}: "
+            f"{self.label} / {self.instance_label}>"
+        )
+
+    def _reset(self) -> None:
+        self.serial = None
+        self.label = None
+        self.instance_label = None
+        self._value = None
+        self.client_data = {}
+
+    def interview_serialize(self) -> str:
+        return json.dumps({
+            "serial": self.serial,
+            "label": self.label,
+            "instance_label": self.instance_label,
+        })
+
+    def interview_hydrate(self, data: str | dict[str, Any]) -> bool:
+        try:
+            data = _loads_interview_data(data)
+            self.serial = data.get("serial")
+            self.label = data.get("label")
+            self.instance_label = data.get("instance_label")
+            self.instance.address.label = self.label
+            self.instance.address.serial = cast(str | None, self.serial)
+            cast(ZenController, self.instance.address.controller).absolute_inputs.add(self)
+            return True
+        except Exception:
+            return False
+
+    async def interview(self) -> bool:
+        inst = self.instance
+        addr = inst.address
+        ctrl = cast(ZenController, addr.controller)
+        if addr.label is None:
+            addr.label = await self.protocol.query_dali_device_label(addr, generic_if_none=True)
+        if addr.serial is None:
+            addr.serial = cast(str | None, await self.protocol.query_dali_serial(addr))
+        self.label = addr.label
+        self.serial = addr.serial
+        self.instance_label = await self.protocol.query_dali_instance_label(
+            inst, generic_if_none=True
+        )
+        ctrl.absolute_inputs.add(self)
+        return True
+
+    @property
+    def value(self) -> int | None:
+        """Last-known 16-bit value from an absolute-input event, or None."""
+        return self._value
+
+    async def _event_received(self, payload: bytes) -> None:
+        if len(payload) < 3:
+            return
+        new_value = (payload[1] << 8) | payload[2]
+        changed = new_value != self._value
+        self._value = new_value
+        if changed and callable(self.protocol.callbacks.absolute_input_change):
+            await self.protocol.callbacks.absolute_input_change(
+                absolute_input=self, value=new_value
+            )
+
 
 class ZenMotionSensor:
     protocol: ZenProtocol
@@ -1679,6 +1956,7 @@ class ZenSystemVariable:
 
 
 # Callback type definitions (moved here after class definitions)
+type ControllerRuntimeStatus = Literal["online", "starting", "unreachable"]
 type CallbackOnConnect = Callable[[], Awaitable[None]]
 type CallbackOnDisconnect = Callable[[], Awaitable[None]]
 type CallbackProfileChange = Callable[[ZenProfile], Awaitable[None]]
@@ -1686,6 +1964,10 @@ type CallbackGroupChange = Callable[[ZenGroup, int], Awaitable[None]]
 type CallbackLightChange = Callable[[ZenLight, int, ZenColour, int], Awaitable[None]]
 type CallbackButtonPress = Callable[[ZenButton], Awaitable[None]]
 type CallbackButtonLongPress = Callable[[ZenButton], Awaitable[None]]
+type CallbackAbsoluteInputChange = Callable[[ZenAbsoluteInput, int], Awaitable[None]]
 type CallbackMotionEvent = Callable[[ZenMotionSensor, bool], Awaitable[None]]
 type CallbackSystemVariableChange = Callable[[ZenSystemVariable, int, bool, bool], Awaitable[None]]
 type CallbackControllerDiscovered = Callable[[DiscoveredController], Awaitable[None]]
+type CallbackControllerStatusChange = Callable[
+    [ZenController, ControllerRuntimeStatus], Awaitable[None]
+]

{zencontrol_python-0.1.4.dist-info → zencontrol_python-0.1.6.dist-info}/METADATA

@@ -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.dist-info → zencontrol_python-0.1.6.dist-info}/RECORD

@@ -1,5 +1,4 @@
 examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-examples/dump_simulator_config.py,sha256=9788XLn8_-Hmc7YN2Eylnx7QnIjf50Umar0F44DLDrg,18288
 examples/mqtt_bridge.py,sha256=ldSK_zv0vlie6znebyNyqWJdGSoZRO6fijJbvERKRZ0,49882
 examples/live/controller.py,sha256=jFRgkNcribyg4fviJyQkiWfNI5O3lQFhtblFoe8UPiU,1809
 examples/live/devices.py,sha256=UiIVwEpyELfl2IOA-9vR2-pMKn9JLwyOV3htTX7XeD8,1681
@@ -16,22 +15,22 @@ examples/live/multicast_raw.py,sha256=EFRM7xA-xlZFS_0WXkQmqECBITG41W4jUEmTd9sIA1
 examples/live/profiles.py,sha256=Z0jZg8EEznMzSH5JJhhgtJRA_dazNSkuDHnfLqxpR44,1323
 examples/live/tpi_event_listener.py,sha256=phWI7Ib_g_nMGcPMjIZY6ukBpQpp9YdI3l5lAseYSjA,9309
 examples/live/variables.py,sha256=hio4vefJLgvCvoVpxLTrU0kxzStWYn6artoJbGnVyd4,1554
-zencontrol/__init__.py,sha256=9Lg0TqiTAwcJRDrus9mbALr6lBT5hsav0wiAPKWaKzA,2938
+zencontrol/__init__.py,sha256=bS69eXmifqSmw6XCZ5ml534IIft07evyzioVHz4Y7x8,2984
 zencontrol/exceptions.py,sha256=tqaLDYWu5J-j2ZKFdfTOcXLH9vULi5pZn8o_Y86bHRE,862
 zencontrol/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 zencontrol/utils.py,sha256=cipUc2KXUfrgTRbCyGwNLhk7um2tjAw6I7kpU_eOu44,2005
 zencontrol/api/__init__.py,sha256=kZd1T3IKziyQc9qAfOJdYeeTPaB4L2Wkhfu3FKmRw-I,875
 zencontrol/api/models.py,sha256=W3kCFiJSxc9Z_5Bzfx7A1iICLL8PRmMroW1WReEzAfs,12334
-zencontrol/api/protocol.py,sha256=AUxj_uFWScSn7Q7X7ZlMW10ZKVcUAJjPKGwgpNTRS5I,102277
-zencontrol/api/types.py,sha256=cJtKY4Qer8u0QQ8J9Jcumg1C1Dee5DtJ9JGcSEfhIKw,6862
-zencontrol/interface/__init__.py,sha256=gw_-LSlEwUL0vrOYTxTBwPHZmuNsNqXRqVFbz1ZBQuA,662
-zencontrol/interface/interface.py,sha256=qE7ZAD4rxW26V-HggG6tppB5ECzVGljdrWJqO4t2SOs,77752
+zencontrol/api/protocol.py,sha256=zBPCcuvBc6F51LtPbPfFBHzdUro0P1fdNAKprQ61fC8,102471
+zencontrol/api/types.py,sha256=DxCi4dI_iBF5bPo-YqzYnmxA9fbTwp-bsHbD1fOSnVE,7042
+zencontrol/interface/__init__.py,sha256=HNGCBYlJ5W2Pap4DmaQe0EI06j0ZWyy4PCW3HzLLJm8,708
+zencontrol/interface/interface.py,sha256=SVFjlPIyf3oiDtQmET0v0VVAWV1MD1RC-lEGUYbp-x4,89504
 zencontrol/io/__init__.py,sha256=cBfOKr0BqOI8E2LicAwcDzLhdlz7KHHrtcn-iUzRmcU,570
 zencontrol/io/command.py,sha256=HVyMgYGSm166adIIU4KRSIfzPnfB9gnmw3pia_nZ4U8,15366
 zencontrol/io/event.py,sha256=dsjxFCGNljZOMwFqez9aYKvK1WF2w55X7iwsX93mpvQ,12994
-zencontrol_python-0.1.4.dist-info/licenses/LICENSE,sha256=cxmGKzqqXAjXOOw0D0tt5pVkNU9HCormEhNR8dEAYc4,1069
-zencontrol_python-0.1.4.dist-info/METADATA,sha256=zpc1a3g3_r4VXVbz9p3vHa0iEJR03mjMXXCmE_I97V0,5414
-zencontrol_python-0.1.4.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-zencontrol_python-0.1.4.dist-info/entry_points.txt,sha256=bowyQt57_veMMZzF7LvDwDajG2HcY4-99qYHJ_hasw4,62
-zencontrol_python-0.1.4.dist-info/top_level.txt,sha256=cKZS8nB2cZlXavIXB_0tzE16PfGGw6WZDqNzemZKZ4w,20
-zencontrol_python-0.1.4.dist-info/RECORD,,
+zencontrol_python-0.1.6.dist-info/licenses/LICENSE,sha256=cxmGKzqqXAjXOOw0D0tt5pVkNU9HCormEhNR8dEAYc4,1069
+zencontrol_python-0.1.6.dist-info/METADATA,sha256=-SqcQjeXr4oeskshMZ5FGo1OEPwM_S6sW4xpd3gbgBM,5698
+zencontrol_python-0.1.6.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+zencontrol_python-0.1.6.dist-info/entry_points.txt,sha256=bowyQt57_veMMZzF7LvDwDajG2HcY4-99qYHJ_hasw4,62
+zencontrol_python-0.1.6.dist-info/top_level.txt,sha256=cKZS8nB2cZlXavIXB_0tzE16PfGGw6WZDqNzemZKZ4w,20
+zencontrol_python-0.1.6.dist-info/RECORD,,

examples/dump_simulator_config.py

@@ -1,474 +0,0 @@
-#!/usr/bin/env python3
-"""Dump a live Zencontrol controller into a zencontrol-simulator config.yaml.
-
-Read-only: queries labels, levels, colour, scenes, groups, ECDs/instances,
-profiles, and system variables. Does not send control commands.
-
-Example:
-  cd zencontrol-python
-  python examples/dump_simulator_config.py \\
-      -c examples/config.yaml \\
-      -o ../zencontrol-simulator/config.from-live.yaml
-"""
-
-import argparse
-import asyncio
-import logging
-import sys
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from zencontrol import (
-    ZenColour,
-    ZenColourType,
-    ZenController,
-    ZenInstanceType,
-    ZenProtocol,
-    run_with_keyboard_interrupt,
-)
-from zencontrol.api.types import Const
-
-LOGGER = logging.getLogger("dump_simulator_config")
-
-INSTANCE_TYPE_NAMES = {
-    ZenInstanceType.PUSH_BUTTON: "push_button",
-    ZenInstanceType.ABSOLUTE_INPUT: "absolute_input",
-    ZenInstanceType.OCCUPANCY_SENSOR: "occupancy_sensor",
-    ZenInstanceType.LIGHT_SENSOR: "light_sensor",
-    ZenInstanceType.GENERAL_SENSOR: "general_sensor",
-}
-
-def _hex_int(value: int) -> str:
-    return f"0x{value:X}"
-
-def _colour_dict(colour: ZenColour | None) -> dict[str, Any] | None:
-    if colour is None or colour.type is None:
-        return None
-    if colour.type == ZenColourType.TC:
-        return {"type": "tc", "kelvin": colour.kelvin}
-    if colour.type == ZenColourType.RGBWAF:
-        return {
-            "type": "rgbwaf",
-            "r": colour.r,
-            "g": colour.g,
-            "b": colour.b,
-            "w": colour.w if colour.w is not None else 0,
-            "a": colour.a if colour.a is not None else 0,
-            "f": colour.f if colour.f is not None else 0,
-        }
-    if colour.type == ZenColourType.XY:
-        return {"type": "xy", "x": colour.x, "y": colour.y}
-    return None
-
-def _scene_levels(levels: list[int | None] | None) -> list[int | None]:
-    out: list[int | None] = [None] * 12
-    if not levels:
-        return out
-    for i, level in enumerate(levels[:12]):
-        out[i] = None if level is None else int(level)
-    return out
-
-def _scene_colours(colours: list[ZenColour | None] | None) -> list[dict[str, Any] | None]:
-    out: list[dict[str, Any] | None] = [None] * 12
-    if not colours:
-        return out
-    for i, colour in enumerate(colours[:12]):
-        out[i] = _colour_dict(colour)
-    return out
-
-async def _raw_byte(tpi: ZenProtocol, controller: ZenController, command: int, address: int = 0) -> int | None:
-    response = await tpi._send_basic(controller, command, address)
-    if response and len(response) >= 1:
-        return int(response[0])
-    return None
-
-async def dump_controller(tpi: ZenProtocol, controller: ZenController) -> dict[str, Any]:
-    LOGGER.info("Querying controller %s (%s:%s)", controller.mac, controller.host, controller.port)
-
-    version = await tpi.query_controller_version_number(controller)
-    version_parts = [2, 2, 0]
-    if isinstance(version, str):
-        try:
-            version_parts = [int(x) for x in version.split(".")[:3]]
-            while len(version_parts) < 3:
-                version_parts.append(0)
-        except ValueError:
-            pass
-    label = await tpi.query_controller_label(controller) or controller.label or "Controller"
-    startup = await tpi.query_controller_startup_complete(controller)
-    dali_ready = await tpi.query_is_dali_ready(controller)
-    event_mode = await _raw_byte(tpi, controller, tpi.CMD["QUERY_TPI_EVENT_EMIT_STATE"])
-
-    current_profile = await tpi.query_current_profile_number(controller)
-    last_scheduled = current_profile or 0
-    profile_info = await tpi.query_profile_information(controller)
-    if profile_info:
-        state, _profiles_detail = profile_info
-        current_profile = int(state.get("current_active_profile", current_profile or 0))
-        last_scheduled = int(state.get("last_scheduled_profile", last_scheduled))
-
-    profile_numbers = await tpi.query_profile_numbers(controller) or []
-    if current_profile is not None and current_profile not in profile_numbers:
-        profile_numbers = sorted(set(profile_numbers) | {current_profile})
-    profile_items = []
-    for number in sorted(profile_numbers):
-        plabel = await tpi.query_profile_label(controller, number)
-        profile_items.append({
-            "number": int(number),
-            "label": plabel or f"Profile {number}",
-        })
-        LOGGER.info("  profile %s: %s", number, plabel)
-
-    mac = controller.mac.replace("-", ":").lower()
-    world: dict[str, Any] = {
-        "controller": {
-            "bind_host": "0.0.0.0",
-            "bind_port": 5108,
-            "mac": mac,
-            "label": label,
-            "version": version_parts,
-            "startup_complete": bool(startup) if startup is not None else True,
-            "dali_ready": bool(dali_ready) if dali_ready is not None else True,
-            "event_mode": event_mode if event_mode is not None else 0x01,
-            # Dump is a static snapshot — disable occupancy heartbeat by default.
-            "heartbeat_interval": 0,
-        },
-        "lights": [],
-        "groups": [],
-        "devices": [],
-        "profiles": {
-            "current": int(current_profile or 0),
-            "last_scheduled": int(last_scheduled or 0),
-            "items": profile_items,
-        },
-        "system_variables": [],
-    }
-
-    # --- Groups (labels / scenes first so light membership can reference them) ---
-    group_addrs = await tpi.query_group_numbers(controller) or []
-    LOGGER.info("Groups: %d", len(group_addrs))
-    for gaddr in sorted(group_addrs, key=lambda a: a.number):
-        glabel = await tpi.query_group_label(gaddr)
-        glevel = await tpi.dali_query_level(gaddr)
-        scene_nums = await tpi.query_scene_numbers_for_group(gaddr) or []
-        scenes: dict[int, str] = {}
-        for scene in sorted(scene_nums):
-            if not 0 <= scene <= 11:
-                continue
-            slabel = await tpi.query_scene_label_for_group(gaddr, scene)
-            if slabel:
-                scenes[int(scene)] = slabel
-        world["groups"].append({
-            "number": int(gaddr.number),
-            "label": glabel or f"Group {gaddr.number}",
-            "level": 0 if glevel is None else int(glevel),
-            "scenes": scenes,
-        })
-        LOGGER.info("  group %s: %s (%d scenes)", gaddr.number, glabel, len(scenes))
-
-    # --- Control gear / lights ---
-    gears = await tpi.query_control_gear_dali_addresses(controller) or []
-    LOGGER.info("Control gear: %d", len(gears))
-    for addr in sorted(gears, key=lambda a: a.number):
-        status_raw = await _raw_byte(
-            tpi, controller, tpi.CMD["DALI_QUERY_CONTROL_GEAR_STATUS"], addr.ecg()
-        )
-        # Skip gear that does not answer status (absent / failed)
-        if status_raw is None:
-            LOGGER.warning("  ECG %s: no status — skipping", addr.number)
-            continue
-
-        dlabel = await tpi.query_dali_device_label(addr)
-        serial = await tpi.query_dali_serial(addr)
-        level = await tpi.dali_query_level(addr)
-        min_level = await tpi.dali_query_min_level(addr)
-        max_level = await tpi.dali_query_max_level(addr)
-        last_scene = await tpi.dali_query_last_scene(addr)
-        last_current = await tpi.dali_query_last_scene_is_current(addr)
-        cg_types = await tpi.dali_query_cg_type(addr) or []
-        groups = await tpi.query_group_membership_by_address(addr) or []
-        group_nums = sorted({int(g.number) for g in groups})
-
-        colour_features = {
-            "supports_xy": False,
-            "supports_tunable": False,
-            "primary_count": 0,
-            "rgbwaf_channels": 0,
-        }
-        colour = None
-        colour_temp_limits = None
-        if 8 in cg_types:
-            features = await tpi.query_dali_colour_features(addr)
-            if features:
-                colour_features = {
-                    "supports_xy": bool(features.get("supports_xy", False)),
-                    "supports_tunable": bool(features.get("supports_tunable", False)),
-                    "primary_count": int(features.get("primary_count", 0)),
-                    "rgbwaf_channels": int(features.get("rgbwaf_channels", 0)),
-                }
-            colour = _colour_dict(await tpi.query_dali_colour(addr))
-            if colour_features["supports_tunable"]:
-                colour_temp_limits = await tpi.query_dali_colour_temp_limits(addr)
-
-        scene_levels = _scene_levels(await tpi.query_scene_levels_by_address(addr))
-        scene_colours = _scene_colours(await tpi.query_scene_colours_by_address(addr))
-
-        light: dict[str, Any] = {
-            "address": int(addr.number),
-            "label": dlabel or f"Light {addr.number}",
-            "serial": _hex_int(int(serial)) if serial else 0,
-            "level": 0 if level is None else int(level),
-            "min_level": 1 if min_level is None else int(min_level),
-            "max_level": 254 if max_level is None else int(max_level),
-            "last_scene": 0 if last_scene is None else int(last_scene),
-            "last_scene_current": bool(last_current) if last_current is not None else False,
-            "cg_types": [int(x) for x in cg_types],
-            "colour": colour,
-            "colour_features": colour_features,
-            "groups": group_nums,
-            "scene_levels": scene_levels,
-            "status": status_raw,
-        }
-        if colour_temp_limits:
-            light["colour_temp_limits"] = {
-                "physical_warmest": int(colour_temp_limits["physical_warmest"]),
-                "physical_coolest": int(colour_temp_limits["physical_coolest"]),
-                "soft_warmest": int(colour_temp_limits["soft_warmest"]),
-                "soft_coolest": int(colour_temp_limits["soft_coolest"]),
-                "step_value": int(colour_temp_limits["step_value"]),
-            }
-        if any(c is not None for c in scene_colours):
-            light["scene_colours"] = scene_colours
-
-        world["lights"].append(light)
-        LOGGER.info(
-            "  ECG %s: %s level=%s groups=%s cg=%s",
-            addr.number,
-            dlabel,
-            light["level"],
-            group_nums,
-            cg_types,
-        )
-
-    # --- ECDs / instances ---
-    ecds = await tpi.query_dali_addresses_with_instances(controller, 0) or []
-    LOGGER.info("Devices with instances: %d", len(ecds))
-    for ecd in sorted(ecds, key=lambda a: a.number):
-        dlabel = await tpi.query_dali_device_label(ecd)
-        serial = await tpi.query_dali_serial(ecd)
-        instances = await tpi.query_instances_by_address(ecd) or []
-        inst_list: list[dict[str, Any]] = []
-        for inst in sorted(instances, key=lambda i: i.number):
-            if inst.type is None:
-                continue
-            type_name = INSTANCE_TYPE_NAMES.get(inst.type)
-            if type_name is None:
-                LOGGER.warning(
-                    "  ECD %s inst %s: unsupported type %s — skipped",
-                    ecd.number,
-                    inst.number,
-                    inst.type,
-                )
-                continue
-            ilabel = await tpi.query_dali_instance_label(inst)
-            entry: dict[str, Any] = {
-                "number": int(inst.number),
-                "type": type_name,
-                "label": ilabel or f"Instance {inst.number}",
-                "active": True,
-                "error": False,
-            }
-            if inst.type == ZenInstanceType.OCCUPANCY_SENSOR:
-                timers = await tpi.query_occupancy_instance_timers(inst)
-                if timers:
-                    entry["timers"] = {
-                        "deadtime": int(timers["deadtime"]),
-                        "hold": int(timers["hold"]),
-                        "report": int(timers["report"]),
-                        "last_detect": int(timers["last_detect"]),
-                    }
-                else:
-                    entry["timers"] = {
-                        "deadtime": 1,
-                        "hold": 60,
-                        "report": 20,
-                        "last_detect": 0,
-                    }
-            inst_list.append(entry)
-            LOGGER.info(
-                "  ECD %s.%s %s (%s)",
-                ecd.number,
-                inst.number,
-                type_name,
-                ilabel,
-            )
-        if not inst_list:
-            continue
-        world["devices"].append({
-            "address": int(ecd.number),
-            "label": dlabel or f"Device {ecd.number}",
-            "serial": _hex_int(int(serial)) if serial else 0,
-            "instances": inst_list,
-        })
-
-    # --- System variables (stop after consecutive unnamed IDs) ---
-    give_up_after = 10
-    failed = 0
-    LOGGER.info("System variables…")
-    for vid in range(Const.MAX_SYSVAR):
-        name = await tpi.query_system_variable_name(controller, vid)
-        if not name:
-            failed += 1
-            if failed >= give_up_after:
-                break
-            continue
-        failed = 0
-        value = await tpi.query_system_variable(controller, vid)
-        world["system_variables"].append({
-            "id": int(vid),
-            "name": name,
-            "value": 0 if value is None else int(value),
-        })
-        LOGGER.info("  sysvar %s: %s = %s", vid, name, value)
-
-    return world
-
-class _HexInt(int):
-    """YAML representable int that dumps as 0x…."""
-
-def _represent_hex_int(dumper: yaml.Dumper, data: _HexInt) -> Any:
-    return dumper.represent_scalar("tag:yaml.org,2002:int", f"0x{int(data):X}")
-
-def _prepare_for_yaml(obj: Any) -> Any:
-    """Convert serial hex strings back to ints tagged for hex dump where useful."""
-    if isinstance(obj, dict):
-        out = {}
-        for key, value in obj.items():
-            if key == "serial" and isinstance(value, str) and value.startswith("0x"):
-                out[key] = _HexInt(int(value, 0))
-            elif key == "event_mode" and isinstance(value, int):
-                out[key] = _HexInt(value)
-            elif key == "status" and isinstance(value, int):
-                out[key] = _HexInt(value)
-            else:
-                out[key] = _prepare_for_yaml(value)
-        return out
-    if isinstance(obj, list):
-        return [_prepare_for_yaml(x) for x in obj]
-    return obj
-
-def write_yaml(path: Path, world: dict[str, Any]) -> None:
-    class Dumper(yaml.SafeDumper):
-        pass
-
-    Dumper.add_representer(_HexInt, _represent_hex_int)
-    payload = _prepare_for_yaml(world)
-    header = (
-        "# Auto-generated by zencontrol-python/examples/dump_simulator_config.py\n"
-        "# Read-only snapshot of a live Zencontrol controller for zencontrol-simulator.\n"
-        "# Control commands mutate in-memory state only; nothing is written back to disk.\n\n"
-    )
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with open(path, "w", encoding="utf-8") as fh:
-        fh.write(header)
-        yaml.dump(
-            payload,
-            fh,
-            Dumper=Dumper,
-            sort_keys=False,
-            default_flow_style=False,
-            allow_unicode=True,
-            width=100,
-        )
-
-def build_parser() -> argparse.ArgumentParser:
-    example_dir = Path(__file__).resolve().parent
-    default_config = example_dir / "config.yaml"
-    default_out = example_dir.parents[1] / "zencontrol-simulator" / "config.from-live.yaml"
-    parser = argparse.ArgumentParser(
-        description="Dump a live Zencontrol controller to a zencontrol-simulator YAML world",
-    )
-    parser.add_argument(
-        "-c",
-        "--config",
-        type=Path,
-        default=default_config,
-        help=f"zencontrol-python config.yaml (default: {default_config})",
-    )
-    parser.add_argument(
-        "-o",
-        "--output",
-        type=Path,
-        default=default_out,
-        help=f"Output simulator config path (default: {default_out})",
-    )
-    parser.add_argument(
-        "--controller",
-        type=int,
-        default=0,
-        help="Index into zencontrol: list in config (default: 0)",
-    )
-    parser.add_argument(
-        "-v",
-        "--verbose",
-        action="store_true",
-        help="Debug logging",
-    )
-    return parser
-
-async def main(argv: list[str] | None = None) -> None:
-    args = build_parser().parse_args(argv)
-    logging.basicConfig(
-        level=logging.DEBUG if args.verbose else logging.INFO,
-        format="%(asctime)s %(levelname)s %(message)s",
-    )
-
-    if not args.config.is_file():
-        LOGGER.error("Config not found: %s", args.config)
-        sys.exit(1)
-
-    with open(args.config, encoding="utf-8") as fh:
-        config = yaml.safe_load(fh) or {}
-    controllers = config.get("zencontrol") or []
-    if not controllers:
-        LOGGER.error("No zencontrol: entries in %s", args.config)
-        sys.exit(1)
-    if not 0 <= args.controller < len(controllers):
-        LOGGER.error("Controller index %s out of range (have %d)", args.controller, len(controllers))
-        sys.exit(1)
-
-    entry = dict(controllers[args.controller])
-    # ZenController / ZenProtocol do not need mqtt extras
-    for key in ("system_variables", "buttons", "unicast_ip", "unicast_port", "filtering"):
-        entry.pop(key, None)
-
-    async with ZenProtocol(print_traffic=False) as tpi:
-        # Coerce YAML types to what ZenController expects
-        entry["id"] = str(entry.get("id", "1"))
-        ctrl = ZenController(protocol=tpi, **entry)
-        tpi.set_controllers([ctrl])
-
-        ready = await tpi.query_controller_startup_complete(ctrl)
-        if ready is False:
-            LOGGER.warning("Controller reports startup incomplete — continuing anyway")
-        dali = await tpi.query_is_dali_ready(ctrl)
-        if dali is False:
-            LOGGER.warning("DALI bus not ready — continuing anyway")
-
-        world = await dump_controller(tpi, ctrl)
-
-    write_yaml(args.output, world)
-    LOGGER.info(
-        "Wrote %s (%d lights, %d groups, %d devices, %d profiles, %d sysvars)",
-        args.output,
-        len(world["lights"]),
-        len(world["groups"]),
-        len(world["devices"]),
-        len(world["profiles"]["items"]),
-        len(world["system_variables"]),
-    )
-
-if __name__ == "__main__":
-    run_with_keyboard_interrupt(main)