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

examples/dump_simulator_config.py

@@ -11,14 +11,12 @@ Example:
       -o ../zencontrol-simulator/config.from-live.yaml
 """
 
-from __future__ import annotations
-
 import argparse
 import asyncio
 import logging
 import sys
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 import yaml
 
@@ -42,12 +40,10 @@ INSTANCE_TYPE_NAMES = {
     ZenInstanceType.GENERAL_SENSOR: "general_sensor",
 }
 
-
 def _hex_int(value: int) -> str:
     return f"0x{value:X}"
 
-
-def _colour_dict(colour: Optional[ZenColour]) -> Optional[dict[str, Any]]:
+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:
@@ -66,32 +62,28 @@ def _colour_dict(colour: Optional[ZenColour]) -> Optional[dict[str, Any]]:
         return {"type": "xy", "x": colour.x, "y": colour.y}
     return None
 
-
-def _scene_levels(levels: list[Optional[int]] | None) -> list[Optional[int]]:
-    out: list[Optional[int]] = [None] * 12
+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[Optional[ZenColour]] | None) -> list[Optional[dict[str, Any]]]:
-    out: list[Optional[dict[str, Any]]] = [None] * 12
+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) -> Optional[int]:
+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)
 
@@ -343,15 +335,12 @@ async def dump_controller(tpi: ZenProtocol, controller: ZenController) -> dict[s
 
     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):
@@ -370,7 +359,6 @@ def _prepare_for_yaml(obj: Any) -> Any:
         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
@@ -395,7 +383,6 @@ def write_yaml(path: Path, world: dict[str, Any]) -> None:
             width=100,
         )
 
-
 def build_parser() -> argparse.ArgumentParser:
     example_dir = Path(__file__).resolve().parent
     default_config = example_dir / "config.yaml"
@@ -431,7 +418,6 @@ def build_parser() -> argparse.ArgumentParser:
     )
     return parser
 
-
 async def main(argv: list[str] | None = None) -> None:
     args = build_parser().parse_args(argv)
     logging.basicConfig(
@@ -484,6 +470,5 @@ async def main(argv: list[str] | None = None) -> None:
         len(world["system_variables"]),
     )
 
-
 if __name__ == "__main__":
     run_with_keyboard_interrupt(main)

examples/live/interface_events.py

@@ -3,7 +3,6 @@ from zencontrol import ZenControl, ZenProfile, ZenGroup, ZenLight, ZenButton, Ze
 import yaml
 from pathlib import Path
 import time
-from typing import Optional
 
 async def main():
     config = yaml.safe_load(open(Path(__file__).resolve().parents[2] / "tests" / "config.yaml"))
@@ -21,11 +20,11 @@ async def main():
         ms()
         print(f"Profile Change Event     - {profile}")
 
-    async def _zen_group_change(group: ZenGroup, level: Optional[int] = None, colour: Optional[ZenColour] = None, scene: Optional[int] = None, discoordinated: bool = False) -> None:
+    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: Optional[int] = None, colour: Optional[ZenColour] = None, scene: Optional[int] = None) -> None:
+    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}")
 

examples/mqtt_bridge.py

@@ -5,7 +5,7 @@ import json
 import yaml
 import re
 from pathlib import Path
-from typing import Optional, Any
+from typing import Any
 import zencontrol
 from zencontrol import ZenController, ZenProtocol, ZenClient, ZenColour, ZenColourType, ZenProfile, ZenLight, ZenGroup, ZenButton, ZenMotionSensor, ZenSystemVariable, ZenTimeoutError, ZenAddressType
 from zencontrol.api.types import Const as ApiConst
@@ -814,9 +814,9 @@ class ZenMQTTBridge:
     async def _mqtt_light_change(self, light: ZenLight|ZenGroup, payload: dict[str, Any]) -> None:
         addr = light.address
         ctrl = addr.controller
-        state: Optional[str] = payload.get("state", None)
-        brightness: Optional[int] = payload.get("brightness", None)
-        mireds: Optional[int] = payload.get("color_temp", None)
+        state: str | None = payload.get("state", None)
+        brightness: int | None = payload.get("brightness", None)
+        mireds: int | None = payload.get("color_temp", None)
 
         # If brightness or temperature is set
         if brightness is not None or mireds is not None:
@@ -835,7 +835,7 @@ class ZenMQTTBridge:
             self.logger.info(f"♥️💡 Command from HA: {ctrl.name} turning gear {addr.number} ON")
             await light.on()
 
-    async def _zen_light_change(self, light: ZenLight, level: Optional[int] = None, colour: Optional[ZenColour] = None, scene: Optional[int] = None) -> None:
+    async def _zen_light_change(self, light: ZenLight, level: int | None = None, colour: ZenColour | None = None, scene: int | None = None) -> None:
         typestr = "group" if light.address.type == ZenAddressType.GROUP else "light"
         emoji = "👥" if light.address.type == ZenAddressType.GROUP else "💡"
         self.logger.info(f"🩵{emoji} Event from Zen: {typestr} {light.address.number}  level {level if level is not None else '--'}  colour {colour if colour is not None else '--'}  scene {scene if scene is not None else '--'}")
@@ -930,7 +930,7 @@ class ZenMQTTBridge:
     
     # mqtt group light change calls _mqtt_light_change
         
-    async def _zen_group_change(self, group: ZenGroup, level: Optional[int] = None, colour: Optional[ZenColour] = None, scene: Optional[int] = None, discoordinated: Optional[bool] = None) -> None:
+    async def _zen_group_change(self, group: ZenGroup, level: int | None = None, colour: ZenColour | None = None, scene: int | None = None, discoordinated: bool | None = None) -> None:
         select_mqtt_topic = group.client_data.get("select", {}).get('mqtt_topic', None)
 
         # Get the scene label for the ID from the group
@@ -1109,4 +1109,4 @@ async def main():
         await bridge.stop()
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

zencontrol/__init__.py

@@ -58,7 +58,7 @@ from .exceptions import ZenError, ZenTimeoutError, ZenResponseError, ZenConnecti
 # Utilities
 from .utils import run_with_keyboard_interrupt
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 __author__ = "Simon Wright"
 
 # Public API - these are the main classes users should import

zencontrol/api/models.py

@@ -12,7 +12,7 @@ import socket
 import struct
 import time
 from dataclasses import dataclass, field
-from typing import Any, Optional, Self
+from typing import Any, Self
 
 from ..io import ZenClient
 from .types import ZenAddressType, ZenInstanceType, ZenColourType, Const
@@ -21,13 +21,13 @@ from .types import ZenAddressType, ZenInstanceType, ZenColourType, Const
 DEFAULT_CONTROLLER_PORT = 5108
 
 
-@dataclass(frozen=True)
+@dataclass(frozen=True, slots=True)
 class DiscoveredController:
     """A controller identified from multicast events (not yet registered)."""
 
     host: str
     mac: str
-    label: Optional[str] = None
+    label: str | None = None
     port: int = DEFAULT_CONTROLLER_PORT
 
 
@@ -43,17 +43,17 @@ class ZenController:
     label: str
     host: str
     port: int
-    mac: Optional[str] = None
-    mac_bytes: Optional[bytes] = field(init=False, default=None)
+    mac: str | None = None
+    mac_bytes: bytes | None = field(init=False, default=None)
     # Any avoids an import cycle with protocol.py (which imports this module).
-    protocol: Optional[Any] = None
-    version: Optional[str] = None
+    protocol: Any | None = None
+    version: str | None = None
     startup_complete: bool = False
     dali_ready: bool = False
     filtering: bool = False
     last_seen: float = field(default_factory=time.time)
-    client: Optional[ZenClient] = None
-    _ip: Optional[str] = field(init=False, repr=False, default=None)
+    client: ZenClient | None = None
+    _ip: str | None = field(init=False, repr=False, default=None)
 
     def __post_init__(self):
         self._update_mac_bytes(self.mac)
@@ -64,7 +64,7 @@ class ZenController:
         if name == "mac" and "mac_bytes" in self.__dict__:
             self._update_mac_bytes(value if isinstance(value, str) or value is None else None)
 
-    def _update_mac_bytes(self, value: Optional[str]) -> None:
+    def _update_mac_bytes(self, value: str | None) -> None:
         """Update mac_bytes from a MAC string (or clear it)."""
         if value is not None:
             try:
@@ -101,14 +101,14 @@ class ZenController:
         return self.ip
 
 
-@dataclass
+@dataclass(slots=True)
 class ZenAddress:
     """Represents a DALI address"""
     controller: ZenController
     type: ZenAddressType
     number: int
-    label: Optional[str] = field(default=None, init=False)
-    serial: Optional[str] = field(default=None, init=False)
+    label: str | None = field(default=None, init=False)
+    serial: str | None = field(default=None, init=False)
     
     @classmethod
     def broadcast(cls, controller: ZenController) -> Self:
@@ -168,14 +168,14 @@ class ZenAddress:
                     raise ValueError(f"Group address must be 0-15, got {self.number}")
 
 
-@dataclass
+@dataclass(slots=True)
 class ZenInstance:
     """Represents a DALI ECD instance"""
     address: ZenAddress
     type: ZenInstanceType
     number: int
-    active: Optional[bool] = None
-    error: Optional[bool] = None
+    active: bool | None = None
+    error: bool | None = None
     def __post_init__(self):
         if not 0 <= self.number < Const.MAX_INSTANCE: 
             raise ValueError(f"Instance number must be between 0 and {Const.MAX_INSTANCE-1}, received {self.number}")
@@ -185,100 +185,125 @@ class ZenInstance:
         return f"{self.address.entity_id_string()}_{self.number}"
 
 
-@dataclass
+@dataclass(slots=True)
 class ZenColour:
     """Represents a DALI color"""
-    type: Optional[ZenColourType] = None
-    kelvin: Optional[int] = None
-    r: Optional[int] = None
-    g: Optional[int] = None
-    b: Optional[int] = None
-    w: Optional[int] = None
-    a: Optional[int] = None
-    f: Optional[int] = None
-    x: Optional[int] = None
-    y: Optional[int] = None
+    type: ZenColourType | None = None
+    kelvin: int | None = None
+    r: int | None = None
+    g: int | None = None
+    b: int | None = None
+    w: int | None = None
+    a: int | None = None
+    f: int | None = None
+    x: int | None = None
+    y: int | None = None
     
     @classmethod
-    def from_bytes(cls, bytes: bytes) -> Optional[Self]:
-        if not bytes: # If bytes is empty, return None
-            return None
-        if bytes[0] == ZenColourType.RGBWAF.value and len(bytes) == 7:
-            return cls(type=ZenColourType.RGBWAF, r=bytes[1], g=bytes[2], b=bytes[3], w=bytes[4], a=bytes[5], f=bytes[6])
-        if bytes[0] == ZenColourType.TC.value and (len(bytes) == 3 or len(bytes) == 7):
-            kelvin = (bytes[1] << 8) | bytes[2]
-            return cls(type=ZenColourType.TC, kelvin=kelvin)
-        if bytes[0] == ZenColourType.XY.value and (len(bytes) == 5 or len(bytes) == 7):
-            x = (bytes[1] << 8) | bytes[2]
-            y = (bytes[3] << 8) | bytes[4]
-            return cls(type=ZenColourType.XY, x=x, y=y)
-        return None
+    def from_bytes(cls, data: bytes) -> Self | None:
+        match list(data):
+            case [ZenColourType.RGBWAF.value, r, g, b, w, a, f]:
+                return cls(type=ZenColourType.RGBWAF, r=r, g=g, b=b, w=w, a=a, f=f)
+            case [ZenColourType.TC.value, hi, lo] | [ZenColourType.TC.value, hi, lo, *_]:
+                if len(data) not in (3, 7):
+                    return None
+                return cls(type=ZenColourType.TC, kelvin=(hi << 8) | lo)
+            case [ZenColourType.XY.value, xh, xl, yh, yl] | [ZenColourType.XY.value, xh, xl, yh, yl, *_]:
+                if len(data) not in (5, 7):
+                    return None
+                return cls(type=ZenColourType.XY, x=(xh << 8) | xl, y=(yh << 8) | yl)
+            case _:
+                return None
     
     def __post_init__(self):
-        if self.type == ZenColourType.TC:
-            kelvin = self.kelvin
-            if kelvin is None:
-                raise ValueError("Kelvin is required for TC colour type")
-            if not Const.MIN_KELVIN <= kelvin <= Const.MAX_KELVIN:
-                #raise ValueError(f"Kelvin must be between {Const.MIN_KELVIN} and {Const.MAX_KELVIN}, received {self.kelvin}")
-                logging.getLogger(__name__).warning(
-                    "Kelvin %s out of range [%s, %s]; clamping",
-                    kelvin, Const.MIN_KELVIN, Const.MAX_KELVIN,
-                )
-                # set to the nearest valid value
-                self.kelvin = max(Const.MIN_KELVIN, min(Const.MAX_KELVIN, kelvin))
-        if self.type == ZenColourType.RGBWAF:
-            r, g, b = self.r, self.g, self.b
-            if r is None or not 0 <= r <= 255:
-                raise ValueError(f"R must be between 0 and 255, received {self.r}")
-            if g is None or not 0 <= g <= 255:
-                raise ValueError(f"G must be between 0 and 255, received {self.g}")
-            if b is None or not 0 <= b <= 255:
-                raise ValueError(f"B must be between 0 and 255, received {self.b}")
-            if self.w is not None and not 0 <= self.w <= 255:
-                raise ValueError(f"W must be between 0 and 255, received {self.w}")
-            if self.a is not None and not 0 <= self.a <= 255:
-                raise ValueError(f"A must be between 0 and 255, received {self.a}")
-            if self.f is not None and not 0 <= self.f <= 255:
-                raise ValueError(f"F must be between 0 and 255, received {self.f}")
-        if self.type == ZenColourType.XY:
-            x, y = self.x, self.y
-            if x is None or not 0 <= x <= 65535:
-                raise ValueError(f"X must be between 0 and 65535, received {self.x}")
-            if y is None or not 0 <= y <= 65535:
-                raise ValueError(f"Y must be between 0 and 65535, received {self.y}")
+        match self.type:
+            case ZenColourType.TC:
+                kelvin = self.kelvin
+                if kelvin is None:
+                    raise ValueError("Kelvin is required for TC colour type")
+                if not Const.MIN_KELVIN <= kelvin <= Const.MAX_KELVIN:
+                    logging.getLogger(__name__).warning(
+                        "Kelvin %s out of range [%s, %s]; clamping",
+                        kelvin, Const.MIN_KELVIN, Const.MAX_KELVIN,
+                    )
+                    self.kelvin = max(Const.MIN_KELVIN, min(Const.MAX_KELVIN, kelvin))
+            case ZenColourType.RGBWAF:
+                r, g, b = self.r, self.g, self.b
+                if r is None or not 0 <= r <= 255:
+                    raise ValueError(f"R must be between 0 and 255, received {self.r}")
+                if g is None or not 0 <= g <= 255:
+                    raise ValueError(f"G must be between 0 and 255, received {self.g}")
+                if b is None or not 0 <= b <= 255:
+                    raise ValueError(f"B must be between 0 and 255, received {self.b}")
+                if self.w is not None and not 0 <= self.w <= 255:
+                    raise ValueError(f"W must be between 0 and 255, received {self.w}")
+                if self.a is not None and not 0 <= self.a <= 255:
+                    raise ValueError(f"A must be between 0 and 255, received {self.a}")
+                if self.f is not None and not 0 <= self.f <= 255:
+                    raise ValueError(f"F must be between 0 and 255, received {self.f}")
+            case ZenColourType.XY:
+                x, y = self.x, self.y
+                if x is None or not 0 <= x <= 65535:
+                    raise ValueError(f"X must be between 0 and 65535, received {self.x}")
+                if y is None or not 0 <= y <= 65535:
+                    raise ValueError(f"Y must be between 0 and 65535, received {self.y}")
+            case _:
+                pass
     
     def __repr__(self) -> str:
-        if self.type == ZenColourType.TC:
-            return f"ZenColour(kelvin={self.kelvin})"
-        if self.type == ZenColourType.RGBWAF:
-            return f"ZenColour(r={self.r}, g={self.g}, b={self.b}, w={self.w}, a={self.a}, f={self.f})"
-        if self.type == ZenColourType.XY:
-            return f"ZenColour(x={self.x}, y={self.y})"
-        return f"ZenColour(type={self.type})"
-    
-    def __eq__(self, other):
-        if isinstance(other, self.__class__):
-            return self.__dict__ == other.__dict__
-        else:
-            return False
+        match self.type:
+            case ZenColourType.TC:
+                return f"ZenColour(kelvin={self.kelvin})"
+            case ZenColourType.RGBWAF:
+                return f"ZenColour(r={self.r}, g={self.g}, b={self.b}, w={self.w}, a={self.a}, f={self.f})"
+            case ZenColourType.XY:
+                return f"ZenColour(x={self.x}, y={self.y})"
+            case _:
+                return f"ZenColour(type={self.type})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ZenColour):
+            return NotImplemented
+        return (
+            self.type == other.type
+            and self.kelvin == other.kelvin
+            and self.r == other.r
+            and self.g == other.g
+            and self.b == other.b
+            and self.w == other.w
+            and self.a == other.a
+            and self.f == other.f
+            and self.x == other.x
+            and self.y == other.y
+        )
     
     def to_bytes(self, level: int = 255) -> bytes:
         """Encode colour data as returned by QUERY_DALI_COLOUR (no address or arc level)."""
-        if self.type == ZenColourType.TC:
-            return struct.pack('>BH', 0x20, self.kelvin)
-        if self.type == ZenColourType.RGBWAF:
-            return struct.pack('BBBBBBB', 0x80, self.r, self.g, self.b, self.w if self.w is not None else 0, self.a if self.a is not None else 0, self.f if self.f is not None else 0)
-        if self.type == ZenColourType.XY:
-            return struct.pack('>BHH', 0x10, self.x, self.y)
-        return b''
+        match self.type:
+            case ZenColourType.TC:
+                return struct.pack(">BH", 0x20, self.kelvin)
+            case ZenColourType.RGBWAF:
+                return struct.pack(
+                    "BBBBBBB",
+                    0x80,
+                    self.r,
+                    self.g,
+                    self.b,
+                    self.w if self.w is not None else 0,
+                    self.a if self.a is not None else 0,
+                    self.f if self.f is not None else 0,
+                )
+            case ZenColourType.XY:
+                return struct.pack(">BHH", 0x10, self.x, self.y)
+            case _:
+                return b""
 
     def command_payload(self) -> bytes:
         """Colour type and channel bytes for DALI_COLOUR (follows address and arc level)."""
         return self.to_bytes()
 
 
-@dataclass
+@dataclass(slots=True)
 class ZenProfile:
     """Represents a DALI profile"""
     controller: ZenController