python-dali 0.9__py3-none-any.whl → 0.11__py3-none-any.whl

dali/address.py

@@ -30,11 +30,12 @@ _bad_frame_length = IncompatibleFrame("Unsupported frame size")
 # Address bytes
 ###############################################################################
 
+
 class AddressTracker(type):
     """Metaclass keeping track of all the types of Address we understand."""
 
     def __init__(cls, name, bases, attrs):
-        if not hasattr(cls, '_addrtypes'):
+        if not hasattr(cls, "_addrtypes"):
             cls._addrtypes = []
         else:
             cls._addrtypes.append(cls)
@@ -43,6 +44,8 @@ class AddressTracker(type):
 class Address(metaclass=AddressTracker):
     """An address for one or more ballasts."""
 
+    required_frame_size = None
+
     @classmethod
     def from_frame(cls, f):
         """Return an Address object
@@ -64,72 +67,131 @@ class Address(metaclass=AddressTracker):
         return "<no address>"
 
 
-class Broadcast(Address):
-    """All control gear or devices connected to the network."""
+class GearAddress(Address):
+    """Base class for control gear addresses"""
+
+    required_frame_size = 16
+
+
+class DeviceAddress(Address):
+    """Base class for control device addresses"""
+
+    required_frame_size = 24
+
+
+class GearBroadcast(GearAddress):
+    """All control gear connected to the network"""
 
     @classmethod
     def from_frame(cls, f):
         if len(f) == 16:
-            if f[15:9] == 0x7f:
-                return cls()
-        elif len(f) == 24:
-            if f[16] and f[23:17] == 0x7f:
+            if f[15:9] == 0x7F:
                 return cls()
 
     def add_to_frame(self, f):
         if len(f) == 16:
-            f[15:9] = 0x7f
-        elif len(f) == 24:
-            f[23:17] = 0x7f
+            f[15:9] = 0x7F
+        else:
+            raise _bad_frame_length
+
+    def __eq__(self, other):
+        return isinstance(other, GearBroadcast)
+
+    def __str__(self):
+        return "<broadcast (control gear)>"
+
+
+# Broadcast alias provided for legacy purposes, new code should avoid
+# ambiguity by using either GearBroadcast or DeviceBroadcast
+Broadcast = GearBroadcast
+
+
+class DeviceBroadcast(DeviceAddress):
+    """All control devices connected to the network"""
+
+    @classmethod
+    def from_frame(cls, f):
+        if len(f) == 24:
+            if f[16] and f[23:17] == 0x7F:
+                return cls()
+
+    def add_to_frame(self, f):
+        if len(f) == 24:
+            f[23:17] = 0x7F
         else:
             raise _bad_frame_length
 
     def __eq__(self, other):
-        return isinstance(other, Broadcast)
+        return isinstance(other, DeviceBroadcast)
 
     def __str__(self):
-        return "<broadcast>"
+        return "<broadcast (control device)>"
 
 
-class BroadcastUnaddressed(Address):
-    """All unaddressed control gear or devices
+class GearBroadcastUnaddressed(GearAddress):
+    """All unaddressed control gear
 
-    All control gear or devices in the system that have no short
-    address assigned.
+    All control gear in the system that have no short address assigned.
     """
 
     @classmethod
     def from_frame(cls, f):
         if len(f) == 16:
-            if f[15:9] == 0x7e:
-                return cls()
-        elif len(f) == 24:
-            if f[16] and f[23:17] == 0x7e:
+            if f[15:9] == 0x7E:
                 return cls()
 
     def add_to_frame(self, f):
         if len(f) == 16:
-            f[15:9] = 0x7e
-        elif len(f) == 24:
-            f[23:17] = 0x7e
+            f[15:9] = 0x7E
+        else:
+            raise _bad_frame_length
+
+    def __eq__(self, other):
+        return isinstance(other, GearBroadcastUnaddressed)
+
+    def __str__(self):
+        return "<broadcast unaddressed (control gear)>"
+
+
+# BroadcastUnaddressed alias provided for legacy purposes, new code should
+# avoid ambiguity by using either GearBroadcastUnaddressed or
+# DeviceBroadcastUnaddressed
+BroadcastUnaddressed = GearBroadcastUnaddressed
+
+
+class DeviceBroadcastUnaddressed(DeviceAddress):
+    """All unaddressed control devices
+
+    All control devices in the system that have no short address assigned.
+    """
+
+    @classmethod
+    def from_frame(cls, f):
+        if len(f) == 24:
+            if f[16] and f[23:17] == 0x7E:
+                return cls()
+
+    def add_to_frame(self, f):
+        if len(f) == 24:
+            f[23:17] = 0x7E
         else:
             raise _bad_frame_length
 
     def __eq__(self, other):
-        return isinstance(other, BroadcastUnaddressed)
+        return isinstance(other, DeviceBroadcastUnaddressed)
 
     def __str__(self):
-        return "<broadcast unaddressed>"
+        return "<broadcast unaddressed (control device)>"
 
 
-class Group(Address):
-    """All control gear or devices that are members of the specified group."""
+class GearGroup(GearAddress):
+    """All control gear that are members of the specified group"""
 
-    def __init__(self, group):
+    def __init__(self, group: int):
         if not isinstance(group, int):
             raise ValueError("group must be an integer")
-        if group < 0 or group > 31:
-            raise ValueError("group must be in the range 0..31")
+        if group < 0 or group > 15:
+            raise ValueError("group must be in the range 0..15")
         self.group = group
 
     @classmethod
@@ -137,32 +199,59 @@ class Group(Address):
         if len(f) == 16:
             if f[15:13] == 0x4:
                 return cls(f[12:9])
-        elif len(f) == 24:
-            if f[16] and f[23:22] == 0x2:
-                return cls(f[21:17])
 
     def add_to_frame(self, f):
         if len(f) == 16:
-            if self.group > 15:
-                raise IncompatibleFrame(
-                    "Groups 16..31 are not supported in 16-bit forward frames")
             f[15:13] = 0x4
             f[12:9] = self.group
-        elif len(f) == 24:
+        else:
+            raise _bad_frame_length
+
+    def __eq__(self, other):
+        return isinstance(other, GearGroup) and other.group == self.group
+
+    def __str__(self):
+        return f"<group (control gear) {self.group}>"
+
+
+# Group alias provided for legacy purposes, new code should avoid ambiguity
+# by using either GearGroup or DeviceGroup
+Group = GearGroup
+
+
+class DeviceGroup(DeviceAddress):
+    """All control devices that are members of the specified group"""
+
+    def __init__(self, group: int):
+        if not isinstance(group, int):
+            raise ValueError("group must be an integer")
+        if group < 0 or group > 31:
+            raise ValueError("group must be in the range 0..31")
+        self.group = group
+
+    @classmethod
+    def from_frame(cls, f):
+        if len(f) == 24:
+            if f[16] and f[23:22] == 0x2:
+                return cls(f[21:17])
+
+    def add_to_frame(self, f):
+        if len(f) == 24:
             f[23:22] = 0x2
             f[21:17] = self.group
         else:
             raise _bad_frame_length
 
     def __eq__(self, other):
-        return isinstance(other, Group) and other.group == self.group
+        return isinstance(other, DeviceGroup) and other.group == self.group
 
     def __str__(self):
-        return "<group %d>" % self.group
+        return f"<group (control device) {self.group}>"
 
 
-class Short(Address):
-    """The control gear or device that has this address.
+class GearShort(GearAddress):
+    """
+    The control gear that has this address.
 
     In a correctly configured DALI network, no more than one control
     gear will have a particular short address, and no more than one
@@ -184,25 +273,63 @@ class Short(Address):
         if len(f) == 16:
             if not f[15]:
                 return cls(f[14:9])
-        elif len(f) == 24:
-            if f[16] and not f[23]:
-                return cls(f[22:17])
 
     def add_to_frame(self, f):
         if len(f) == 16:
             f[15] = False
             f[14:9] = self.address
-        elif len(f) == 24:
+        else:
+            raise _bad_frame_length
+
+    def __eq__(self, other):
+        return isinstance(other, GearShort) and other.address == self.address
+
+    def __str__(self):
+        return f"<address (control gear) {self.address}>"
+
+
+# Short alias provided for legacy purposes, new code should avoid ambiguity
+# by using either GearShort or DeviceShort
+Short = GearShort
+
+
+class DeviceShort(DeviceAddress):
+    """
+    The control device that has this address.
+
+    In a correctly configured DALI network, no more than one control
+    gear will have a particular short address, and no more than one
+    control device will have a particular short address.  The short
+    address spaces for control gear and control devices are separate;
+    it is legal for a control gear and control device to share a short
+    address.
+    """
+
+    def __init__(self, address: int):
+        if not isinstance(address, int):
+            raise ValueError("address must be an integer")
+        if address < 0 or address > 63:
+            raise ValueError("address must be in the range 0..63")
+        self.address = address
+
+    @classmethod
+    def from_frame(cls, f):
+        if len(f) == 24:
+            if f[16] and not f[23]:
+                return cls(f[22:17])
+
+    def add_to_frame(self, f):
+        if len(f) == 24:
             f[23] = False
             f[22:17] = self.address
         else:
             raise _bad_frame_length
 
     def __eq__(self, other):
-        return isinstance(other, Short) and other.address == self.address
+        return isinstance(other, DeviceShort) and other.address == self.address
 
     def __str__(self):
-        return "<address %d>" % self.address
+        return f"<address (control device) {self.address}>"
 
 
 from_frame = Address.from_frame
@@ -212,13 +339,27 @@ from_frame = Address.from_frame
 # Instance bytes
 ###############################################################################
 
+
 class Instance:
     def __init__(self):
         raise NotImplementedError
 
+    @property
+    def value(self):
+        if hasattr(self, "_value"):
+            return self._value
+
     def add_to_frame(self, f):
         raise NotImplementedError
 
+    def __eq__(self, other):
+        if isinstance(other, self.__class__):
+            if hasattr(self, "_value") and hasattr(other, "_value"):
+                if self._value == other._value:
+                    return True
+
+        return False
+
 
 class ReservedInstance(Instance):
     """A reserved instance byte."""
@@ -278,7 +419,7 @@ class InstanceGroup(_AddressedInstance):
 
 
 class InstanceType(_AddressedInstance):
-    _flags = 0xc0
+    _flags = 0xC0
 
 
 class FeatureInstanceNumber(_AddressedInstance):
@@ -286,7 +427,7 @@ class FeatureInstanceNumber(_AddressedInstance):
 
 
 class FeatureInstanceGroup(_AddressedInstance):
-    _flags = 0xa0
+    _flags = 0xA0
 
 
 class FeatureInstanceType(_AddressedInstance):
@@ -294,19 +435,19 @@ class FeatureInstanceType(_AddressedInstance):
 
 
 class FeatureInstanceBroadcast(_UnaddressedInstance):
-    _val = 0xfd
+    _val = 0xFD
 
 
 class InstanceBroadcast(_UnaddressedInstance):
-    _val = 0xff
+    _val = 0xFF
 
 
 class FeatureDevice(_UnaddressedInstance):
-    _val = 0xfc
+    _val = 0xFC
 
 
 class Device(_UnaddressedInstance):
-    _val = 0xfe
+    _val = 0xFE
 
 
 def instance_from_frame(f):
@@ -327,12 +468,12 @@ def instance_from_frame(f):
         return FeatureInstanceGroup(p)
     elif flags == 3:
         return FeatureInstanceType(p)
-    elif b == 0xfd:
+    elif b == 0xFD:
         return FeatureInstanceBroadcast()
-    elif b == 0xff:
+    elif b == 0xFF:
         return InstanceBroadcast()
-    elif b == 0xfc:
+    elif b == 0xFC:
         return FeatureDevice()
-    elif b == 0xfe:
+    elif b == 0xFE:
         return Device()
     return ReservedInstance(b)

dali/command.py

@@ -1,5 +1,6 @@
 """Declaration of base types for dali commands and their responses."""
 
+from enum import IntEnum
 from dali import address
 from dali import frame
 from dali.exceptions import MissingResponse
@@ -158,6 +159,21 @@ class BitmapResponse(Response, metaclass=BitmapResponseBitDict):
             return "{}".format(e)
 
 
+class EnumResponse(Response):
+    """
+    A response that consists of a number from a pre-defined enumerator
+    """
+
+    enumerator: IntEnum = None
+
+    @property
+    def value(self):
+        _value = super().value
+        if _value:
+            return self.enumerator(_value.as_integer)  # noqa
+        return _value
+
+
 class Command(metaclass=_CommandTracker):
     """A command frame.
 
@@ -191,7 +207,10 @@ class Command(metaclass=_CommandTracker):
     devicetype = 0
 
     def __init__(self, f):
-        assert isinstance(f, frame.ForwardFrame)
+        if not isinstance(f, frame.ForwardFrame):
+            raise TypeError(
+                f"{self.__class__.__name__} expected a ForwardFrame, not a {type(f)}"
+            )
         self._data = f
 
     _framesizes = {}
@@ -202,7 +221,7 @@ class Command(metaclass=_CommandTracker):
         subs.append(subclass)
 
     @classmethod
-    def from_frame(cls, f, devicetype=0):
+    def from_frame(cls, f, devicetype=0, dev_inst_map=None):
         """Return a Command instance corresponding to the supplied frame.
 
         If the device type the command is intended for is known
@@ -211,6 +230,8 @@ class Command(metaclass=_CommandTracker):
 
         :parameter frame: a forward frame
         :parameter devicetype: type of device frame is intended for
+        :param dev_inst_map: An instance of DeviceInstanceTypeMapper to
+        assist with DALI events
 
         :returns: Return a Command instance corresponding to the
         frame.  Returns None if there is no match.
@@ -222,7 +243,7 @@ class Command(metaclass=_CommandTracker):
         subs = cls._framesizes.get(len(f), [])
 
         for c in subs:
-            r = c.from_frame(f, devicetype=devicetype)
+            r = c.from_frame(f, devicetype=devicetype, dev_inst_map=dev_inst_map)
             if r:
                 return r
 

dali/device/__init__.py

@@ -4,3 +4,8 @@ This module declares commands, responses and event messages defined in
 part 103 ("General requirements - Control devices") and parts 3xx
 (particular requirements for control devices).
 """
+import dali.device.general
+import dali.device.sequences
+import dali.device.pushbutton  # noqa: F401
+import dali.device.occupancy  # noqa: F401
+import dali.device.light  # noqa: F401