zencontrol-python 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

examples/live/controller.py

@@ -0,0 +1,48 @@
+import asyncio
+import yaml
+from pathlib import Path
+from zencontrol import ZenProtocol, ZenController, run_with_keyboard_interrupt
+
+async def main():
+    """Test the async ZenProtocol with controller queries"""
+    # Load configuration
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    
+    # Create protocol and controller
+    async with ZenProtocol(print_traffic=True) as tpi:
+        ctrl = ZenController(protocol=tpi, **config.get('zencontrol')[0])
+        tpi.set_controllers([ctrl])
+        
+        print("Testing ZenController queries...")
+        print("=" * 50)
+        
+        try:
+            # Query controller version
+            version = await tpi.query_controller_version_number(ctrl)
+            print(f"ZenController version: {version}")
+            
+            # Query controller label
+            controller_label = await tpi.query_controller_label(ctrl)
+            print(f"ZenController label: {controller_label}")
+            
+            # Query controller fitting number
+            controller_fitting_number = await tpi.query_controller_fitting_number(ctrl)
+            print(f"ZenController fitting number: {controller_fitting_number}")
+            
+            # Query startup status
+            startup_complete = await tpi.query_controller_startup_complete(ctrl)
+            print(f"ZenController startup complete: {startup_complete}")
+            
+            # Query DALI bus status
+            dali_ready = await tpi.query_is_dali_ready(ctrl)
+            print(f"DALI bus is ready: {dali_ready}")
+            
+        except Exception as e:
+            print(f"Error during testing: {e}")
+        
+        print("=" * 50)
+        print("Test completed!")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)
+

examples/live/devices.py

@@ -0,0 +1,48 @@
+import asyncio
+import yaml
+from pathlib import Path
+from zencontrol import ZenProtocol, ZenController, run_with_keyboard_interrupt
+
+async def main():
+    """Test DALI device queries"""
+    # Load configuration
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    
+    # Create protocol and controller
+    async with ZenProtocol(print_traffic=False) as tpi:
+        ctrl = ZenController(protocol=tpi, **config.get('zencontrol')[0])
+        tpi.set_controllers([ctrl])
+        
+        print("Testing DALI device queries...")
+        print("=" * 50)
+        
+        try:
+            addresses = await tpi.query_dali_addresses_with_instances(ctrl, 0)
+            print(f"Addresses with instances:")
+            
+            for address in addresses:
+                print(f"  {address.number}")
+
+                label = await tpi.query_dali_device_label(address, generic_if_none=True)
+                print(f"    label: {label}")
+
+                operating_mode = await tpi.query_operating_mode_by_address(address)
+                print(f"    operating mode: {operating_mode}")
+
+                serial = await tpi.query_dali_serial(address)
+                print(f"    serial: {serial}")
+
+                ean = await tpi.query_dali_ean(address)
+                print(f"    ean: {ean}")
+
+                fitting = await tpi.query_dali_fitting_number(address)
+                print(f"    fitting: {fitting}")
+                
+        except Exception as e:
+            print(f"Error during testing: {e}")
+        
+        print("=" * 50)
+        print("Test completed!")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)

examples/live/events.py

@@ -0,0 +1,119 @@
+import asyncio
+import logging
+import yaml
+import time
+from pathlib import Path
+import sys
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+sys.stdout.reconfigure(line_buffering=True)
+
+from zencontrol import ZenProtocol, ZenController, ZenAddress, ZenInstance, run_with_keyboard_interrupt
+
+CONFIG_PATH = Path(__file__).resolve().parents[2] / "tests" / "config.yaml"
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s")
+logger = logging.getLogger("test_events")
+
+# Global timing variable for event timing
+timevar = None
+
+def ms():
+    """Print time since last call in milliseconds"""
+    global timevar
+    timevar = timevar or time.time()
+    msecs = (time.time() - timevar) * 1000
+    timevar = time.time()
+    print(f"{msecs:.1f} ms")
+
+# Event handlers — must be async; protocol awaits them
+async def button_press_event(instance: ZenInstance, payload: bytes) -> None:
+    ms()
+    print(f"Button Press Event       - ECD {instance.address.number} instance {instance.number}")
+
+async def level_change_event(address: ZenAddress, arc_level: int, payload: bytes) -> None:
+    ms()
+    print(f"Level Change Event       - {address.type} {address.number} arc_level {arc_level}")
+
+async def group_level_change_event(address: ZenAddress, arc_level: int, payload: bytes) -> None:
+    ms()
+    print(f"Level Change Event Group - {address.type} {address.number} arc_level {arc_level}")
+
+async def scene_change_event(address: ZenAddress, scene: int, active: bool, payload: bytes) -> None:
+    ms()
+    print(f"Scene Change Event       - {address.type} {address.number} scene {scene}")
+
+async def colour_change_event(address: ZenAddress, colour, payload: bytes) -> None:
+    ms()
+    print(f"Colour Change Event      - {address.type} {address.number} colour {colour}")
+
+def check_event_listener(tpi: ZenProtocol) -> None:
+    """Print listener health — call periodically to detect silent task death."""
+    task = tpi.event_task
+    listener = tpi.event_listener
+
+    if task is None:
+        print("LISTENER: event_task not started")
+        return
+    if task.done():
+        exc = task.exception()
+        if exc:
+            print(f"LISTENER: event_task died with {type(exc).__name__}: {exc}")
+        else:
+            print("LISTENER: event_task finished unexpectedly")
+    elif listener is None or not listener.is_listening():
+        print("LISTENER: event_task running but socket is closed")
+    else:
+        print(f"LISTENER: ok (queue size {listener._event_queue.qsize()})")
+
+async def main():
+    """Test async ZenProtocol with event monitoring"""
+    config = yaml.safe_load(CONFIG_PATH.read_text())
+
+    async with ZenProtocol(print_traffic=True, unicast=False, logger=logger) as tpi:
+        ctrl = ZenController(protocol=tpi, **config.get('zencontrol')[0])
+        tpi.set_controllers([ctrl])
+
+        print("Testing ZenProtocol Event Monitoring...")
+        print("=" * 60)
+
+        tpi.set_callbacks(
+            button_press_callback=button_press_event,
+            level_change_callback=level_change_event,
+            group_level_change_callback=group_level_change_event,
+            scene_change_callback=scene_change_event,
+            colour_change_callback=colour_change_event
+        )
+
+        try:
+            print("Querying TPI event configuration...")
+            unicast_config = await tpi.query_tpi_event_unicast_address(ctrl)
+            print(f"TPI Event Unicast Address: {unicast_config}")
+
+            emit_state = await tpi.query_tpi_event_emit_state(ctrl)
+            print(f"TPI Event Emit State: {emit_state}")
+
+        except Exception as e:
+            print(f"Error querying event configuration: {e}")
+
+        print("\nStarting event monitoring...")
+        print("Press Ctrl+C to stop")
+        print("=" * 60)
+
+        await tpi.start_event_monitoring()
+        check_event_listener(tpi)
+
+        try:
+            while True:
+                await asyncio.sleep(5)
+                check_event_listener(tpi)
+        except KeyboardInterrupt:
+            print("\nStopping event monitoring...")
+            await tpi.stop_event_monitoring()
+            print("Event monitoring stopped.")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)

examples/live/gear.py

@@ -0,0 +1,86 @@
+import asyncio
+import yaml
+from pathlib import Path
+from zencontrol import ZenProtocol, ZenController, run_with_keyboard_interrupt
+
+async def main():
+    """Test control gear queries"""
+    # Load configuration
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    
+    # Create protocol and controller
+    async with ZenProtocol(print_traffic=False) as tpi:
+        ctrl = ZenController(protocol=tpi, **config.get('zencontrol')[0])
+        tpi.set_controllers([ctrl])
+        
+        print("Testing control gear queries...")
+        print("=" * 50)
+        
+        try:
+            addresses = await tpi.query_control_gear_dali_addresses(ctrl)
+            print(f"Control gears")    
+
+            
+            for address in addresses[:5]: # Only first 5 gears
+                print(f"  {address.number}")
+
+                level = await tpi.dali_query_level(address)
+                print(f"    current level: {level}")
+
+                label = await tpi.query_dali_device_label(address)
+                print(f"    label: {label}")
+
+                groups = await tpi.query_group_membership_by_address(address)
+                print(f"    groups: {[group.number for group in groups]}")
+                
+                type = await tpi.dali_query_cg_type(address)
+                print(f"    type: {type}")
+
+                colour = await tpi.query_dali_colour(address)
+                print(f"    colour: {colour}")
+                
+                cgtype = await tpi.query_dali_colour_features(address)
+                print(f"    colour features: {cgtype}")
+
+                colour_temp_limits = await tpi.query_dali_colour_temp_limits(address)
+                print(f"    colour temp limits: {colour_temp_limits}")
+
+                fitting = await tpi.query_dali_fitting_number(address)
+                print(f"    fitting: {fitting}")
+
+                ean = await tpi.query_dali_ean(address)
+                print(f"    ean: {ean}")
+
+                serial = await tpi.query_dali_serial(address)
+                print(f"    serial: {serial}")
+
+                last_scene = await tpi.dali_query_last_scene(address)
+                print(f"    last scene: {last_scene}")
+
+                last_scene_is_current = await tpi.dali_query_last_scene_is_current(address)
+                print(f"    last scene is current: {last_scene_is_current}")
+
+                status = await tpi.dali_query_control_gear_status(address)
+                print(f"    status: {status}")
+
+                scenes = await tpi.query_scene_numbers_by_address(address)
+                print(f"    scenes with levels: {scenes}")
+
+                scenes = await tpi.query_colour_scene_membership_by_address(address)
+                print(f"    scenes with colours: {scenes}")
+
+                levels = await tpi.query_scene_levels_by_address(address)
+                print(f"    scene levels: {levels}")
+
+                scene_data = await tpi.query_scene_colours_by_address(address)
+                print(f"    scene colour data: {scene_data}")
+                
+        except Exception as e:
+            print(f"Error during testing: {e}")
+        
+        print("=" * 50)
+        print("Test completed!")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)
+

examples/live/groups.py

@@ -0,0 +1,53 @@
+import asyncio
+import yaml
+from pathlib import Path
+from zencontrol import ZenProtocol, ZenController, run_with_keyboard_interrupt
+
+async def main():
+    """Test group queries"""
+    # Load configuration
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    
+    # Create protocol and controller
+    async with ZenProtocol(print_traffic=True) as tpi:
+        ctrl = ZenController(protocol=tpi, **config.get('zencontrol')[0])
+        tpi.set_controllers([ctrl])
+        
+        print("Testing group queries...")
+        print("=" * 50)
+        
+        try:
+            addresses = await tpi.query_group_numbers(ctrl)
+            print(f"Group")
+
+            for address in addresses:
+                print(f"  {address.number}")
+                name = await tpi.query_group_label(address)
+                print(f"    name: {name}")
+
+                information = await tpi.query_group_by_number(address)
+                print(f"    information: {information}")
+
+                scenes = await tpi.query_scene_numbers_for_group(address)
+                print(f"    scenes: {scenes}")
+
+                for scene in scenes:
+                    label = await tpi.query_scene_label_for_group(address, scene)
+                    print(f"    Group {address.number} scene {scene} label: {label}")
+
+            gear = await tpi.query_control_gear_dali_addresses(ctrl)
+            print(f"Gear")
+            for gear in gear:
+                print(f"  {gear.number}")
+                groups = await tpi.query_group_membership_by_address(gear)
+                for group in groups:
+                    print(f"    group: {group}")
+                    
+        except Exception as e:
+            print(f"Error during testing: {e}")
+        
+        print("=" * 50)
+        print("Test completed!")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)

examples/live/instances.py

@@ -0,0 +1,60 @@
+import asyncio
+import yaml
+from pathlib import Path
+from zencontrol import ZenProtocol, ZenController, run_with_keyboard_interrupt
+
+async def main():
+    """Test instance queries"""
+    # Load configuration
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    
+    # Create protocol and controller
+    async with ZenProtocol(print_traffic=False) as tpi:
+        ctrl = ZenController(protocol=tpi, **config.get('zencontrol')[0])
+        tpi.set_controllers([ctrl])
+        
+        print("Testing instance queries...")
+        print("=" * 50)
+        
+        try:
+            addresses = await tpi.query_dali_addresses_with_instances(ctrl, 0)
+            print(f"Addresses with instances:")
+
+            for address in addresses:
+                print(f"  {address.number}")
+
+                label = await tpi.query_dali_device_label(address)
+                print(f"    label: {label}")
+
+                operating_mode = await tpi.query_operating_mode_by_address(address)
+                print(f"    operating mode: {operating_mode}")
+
+                instances = await tpi.query_instances_by_address(address)
+                # print(f"    instances: {instances}")
+
+                for instance in instances:
+                    
+                    instance_label = await tpi.query_dali_instance_label(instance)
+                    print(f"      {instance.number} - {instance_label}")
+
+                    groups = await tpi.query_instance_groups(instance)
+                    print(f"      groups: {groups}")
+
+                    fitting = await tpi.query_dali_instance_fitting_number(instance)
+                    print(f"      fitting: {fitting}")
+
+                    occupancy_timers = await tpi.query_occupancy_instance_timers(instance)
+                    print(f"      occupancy timers: {occupancy_timers}")
+
+                    last_known_led_state = await tpi.query_last_known_dali_button_led_state(instance)
+                    print(f"      last known led state: {last_known_led_state}")
+                    
+        except Exception as e:
+            print(f"Error during testing: {e}")
+        
+        print("=" * 50)
+        print("Test completed!")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)
+

examples/live/interface.py

@@ -0,0 +1,56 @@
+import asyncio
+from zencontrol import ZenControl, run_with_keyboard_interrupt
+import yaml
+from pathlib import Path
+import time
+
+async def main():
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    zi = ZenControl(print_traffic=False)
+    zi.add_controller(**config.get('zencontrol')[0])
+    await zi.start()
+
+    timer_start = time.time()
+
+    print("Profiles")
+    profiles = await zi.get_profiles()
+    for profile in profiles:
+        print(f"  • {profile}")
+
+    print("Lights")
+    lights = await zi.get_lights()
+    for light in lights:
+        print(f"  • {light}")
+        for group in light.groups:
+            print(f"      • {group}")
+
+    print("Groups")
+    groups = await zi.get_groups()
+    for group in groups:
+        print(f"  • {group}")
+        for light in group.lights:
+            print(f"      • {light}")
+
+    print("Buttons")
+    buttons = await zi.get_buttons()
+    for button in buttons:
+        print(f"  • {button}")
+
+    print("Motion sensors")
+    motion_sensors = await zi.get_motion_sensors()
+    for motion_sensor in motion_sensors:
+        print(f"  • {motion_sensor}")
+        print(f"      = {'occupied' if motion_sensor.occupied else 'not occupied'}")
+
+    print("System variables")
+    system_variables = await zi.get_system_variables()
+    for zsv in system_variables:
+        print(f"  • {zsv}")
+        value = await zsv.get_value()
+        print(f"      = {value}")
+
+    timer_end = time.time()
+    print(f"Time taken: {timer_end - timer_start} seconds")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)

examples/live/interface_events.py

@@ -0,0 +1,80 @@
+import asyncio
+from zencontrol import ZenControl, ZenProfile, ZenGroup, ZenLight, ZenButton, ZenMotionSensor, ZenSystemVariable, ZenColour, run_with_keyboard_interrupt
+import yaml
+from pathlib import Path
+import time
+
+async def main():
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    zi = ZenControl(print_traffic=False)
+    zi.add_controller(**config.get('zencontrol')[0])
+
+    # Handlers
+    async def _zen_on_connect() -> None:
+        print(f"Connected to Zen")
+
+    async def _zen_on_disconnect() -> None:
+        print(f"Disconnected from Zen")
+
+    async def _zen_profile_change(profile: ZenProfile) -> None:
+        ms()
+        print(f"Profile Change Event     - {profile}")
+
+    async def _zen_group_change(group: ZenGroup, level: int | None = None, colour: ZenColour | None = None, scene: int | None = None, discoordinated: bool = False) -> None:
+        ms()
+        print(f"Group Change Event       - {group} level {level} colour {colour} scene {scene} {'discoordinated' if discoordinated else ''}")
+
+    async def _zen_light_change(light: ZenLight, level: int | None = None, colour: ZenColour | None = None, scene: int | None = None) -> None:
+        ms()
+        print(f"Light Change Event       - {light} level {level} colour {colour} scene {scene}")
+
+    async def _zen_button_press(button: ZenButton) -> None:
+        ms()
+        print(f"Button Press Event       - {button}")
+
+    async def _zen_button_long_press(button: ZenButton) -> None:
+        ms()
+        print(f"Button Long Press Event  - {button}")
+
+    async def _zen_motion_event(sensor: ZenMotionSensor, occupied: bool) -> None:
+        ms()
+        print(f"Motion Event             - {sensor} {'occupied' if occupied else 'not occupied'}")
+
+    async def _zen_system_variable_change(system_variable: ZenSystemVariable, value: int, changed: bool, by_me: bool) -> None:
+        ms()
+        print(f"System Variable Change   - {system_variable} value {value} {'changed' if changed else 'not changed'} {'by me' if by_me else 'by someone else'}")
+
+    timevar = None
+    def ms():
+        nonlocal timevar
+        timevar = timevar or time.time()
+        msecs = (time.time() - timevar) * 1000
+        timevar = time.time()
+        print(f"{msecs:.1f} ms")
+
+    # Set up event callbacks
+    # zi.on_connect = _zen_on_connect
+    # zi.on_disconnect = _zen_on_disconnect
+    # zi.profile_change = _zen_profile_change
+    zi.group_change = _zen_group_change
+    zi.light_change = _zen_light_change
+    zi.button_press = _zen_button_press
+    # zi.button_long_press = _zen_button_long_press
+    # zi.motion_event = _zen_motion_event
+    # zi.system_variable_change = _zen_system_variable_change
+
+    # Start event monitoring
+    await zi.start()
+
+    print("Event monitoring started. Press Ctrl+C to stop.")
+    
+    # Loop forever
+    try:
+        while True:
+            await asyncio.sleep(1)
+    except KeyboardInterrupt:
+        print("\nStopping event monitoring...")
+        await zi.stop()
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)

examples/live/leds.py

@@ -0,0 +1,44 @@
+import asyncio
+import yaml
+from pathlib import Path
+from zencontrol import ZenProtocol, ZenController, ZenAddress, ZenAddressType, run_with_keyboard_interrupt
+
+async def main():
+    """Test LED control queries"""
+    # Load configuration
+    config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
+    
+    # Create protocol and controller
+    async with ZenProtocol(print_traffic=False) as tpi:
+        ctrl = ZenController(protocol=tpi, **config.get('zencontrol')[0])
+        tpi.set_controllers([ctrl])
+        
+        print("Testing LED control queries...")
+        print("=" * 50)
+        
+        try:
+            address = ZenAddress(ctrl, ZenAddressType.ECD, 4) # Office
+
+            instances = await tpi.query_instances_by_address(address)
+            print(f"    instances: {instances}")
+
+            for instance in instances:
+                
+                instance_label = await tpi.query_dali_instance_label(instance, generic_if_none=True)
+                print(f"      {instance.number} - {instance_label}")
+
+                last_known_led_state = await tpi.query_last_known_dali_button_led_state(instance)
+                print(f"      last known led state: {last_known_led_state}")
+
+                set_led_state = await tpi.override_dali_button_led_state(instance, False)
+                print(f"      set led state: {set_led_state}")
+                
+        except Exception as e:
+            print(f"Error during testing: {e}")
+        
+        print("=" * 50)
+        print("Test completed!")
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)
+

examples/live/level_change_v2.py

@@ -0,0 +1,77 @@
+import asyncio
+import random
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import yaml
+
+from zencontrol.api.models import ZenAddress, ZenController
+from zencontrol.api.protocol import ZenProtocol
+from zencontrol.api.types import ZenAddressType, ZenEventCode
+from zencontrol.utils import run_with_keyboard_interrupt
+
+CONFIG_PATH = Path(__file__).resolve().parents[2] / "tests" / "config.yaml"
+ECG_ADDRESS = 33
+TIMEOUT_SECONDS = 5.0
+
+
+async def test_level_change_v2():
+    config = yaml.safe_load(CONFIG_PATH.read_text())
+    level = random.randint(100, 250)
+    event_received = asyncio.Event()
+    received: dict = {}
+
+    async with ZenProtocol(print_traffic=True) as tpi:
+        ctrl = ZenController(protocol=tpi, **config["zencontrol"][0])
+        tpi.set_controllers([ctrl])
+
+        original_process = tpi._process_zen_event
+
+        async def capture_level_change_v2(event):
+            if (
+                event.event_code == ZenEventCode.LEVEL_CHANGE_V2.value
+                and event.target == ECG_ADDRESS
+            ):
+                received["event"] = event
+                event_received.set()
+            await original_process(event)
+
+        tpi._process_zen_event = capture_level_change_v2
+
+        await tpi.start_event_monitoring()
+
+        try:
+            address = ZenAddress(ctrl, ZenAddressType.ECG, ECG_ADDRESS)
+            await tpi.dali_arc_level(address, level)
+            print(f"Set address {ECG_ADDRESS} to level {level}, waiting for LEVEL_CHANGE_V2...")
+            await asyncio.wait_for(event_received.wait(), timeout=TIMEOUT_SECONDS)
+        except asyncio.TimeoutError:
+            raise RuntimeError(
+                f"Timed out after {TIMEOUT_SECONDS}s waiting for LEVEL_CHANGE_V2 "
+                f"on address {ECG_ADDRESS} level {level}"
+            ) from None
+        finally:
+            await tpi.stop_event_monitoring()
+
+    event = received["event"]
+    if event.event_code != ZenEventCode.LEVEL_CHANGE_V2.value:
+        raise RuntimeError(f"Expected LEVEL_CHANGE_V2, got event code {event.event_code}")
+    if event.target != ECG_ADDRESS:
+        raise RuntimeError(f"Expected target {ECG_ADDRESS}, got {event.target}")
+
+    current = event.payload[0] if len(event.payload) >= 1 else None
+    target = event.payload[1] if len(event.payload) >= 2 else None
+    print(f"LEVEL_CHANGE_V2 received: address {event.target}, current {current}, target {target}")
+
+
+async def main():
+    await test_level_change_v2()
+    print("Test passed.")
+
+
+if __name__ == "__main__":
+    run_with_keyboard_interrupt(main)