Handle correctly 32bit channels

Author: vanous

pygdtf/__init__.py

@@ -41,7 +41,7 @@
 from .utils import *
 from .value import *  # type: ignore
 
-__version__ = "1.4.3"
+__version__ = "1.4.4-dev5"
 
 # Standard predefined colour spaces: R, G, B, W-P
 COLOR_SPACE_SRGB = ColorSpaceDefinition(
@@ -1696,8 +1696,8 @@ def as_dict(self):
                         "dmx": offset_value,
                         "offset": self.offset,
                         "attribute": self.attribute.str_link,
-                        "default": self.default.get_value(),
-                        "highlight": self.highlight.get_value()
+                        "default": self.default.get_value(full=True),
+                        "highlight": self.highlight.get_value(full=True)
                         if self.highlight is not None
                         else None,
                         "geometry": self.geometry,
@@ -1715,7 +1715,7 @@ def as_dict(self):
                         "offset": self.offset,
                         "attribute": "+" * idx + self.attribute.str_link,
                         "geometry": self.geometry,
-                        "default": self.default.get_value(fine=True),
+                        "default": self.default.get_value(full=True),
                     }
                 )
         return dicts_list
@@ -1951,9 +1951,9 @@ def as_dict(self):
         return {
             "name": self.name,
             "attribute": self.attribute.str_link,
-            "dmx_from": self.dmx_from.get_value(),
-            "dmx_to": self.dmx_to.get_value(),
-            "default": self.default.get_value(),
+            "dmx_from": self.dmx_from.get_value(full=True),
+            "dmx_to": self.dmx_to.get_value(full=True),
+            "default": self.default.get_value(full=True),
             "real_fade": self.real_fade,
             "physical_to": self.physical_to.value,
             "physical_from": self.physical_from.value,
@@ -2142,8 +2142,8 @@ def __repr__(self):
     def as_dict(self):
         return {
             "name": self.name,
-            "dmx_from": self.dmx_from.get_value(),
-            "dmx_to": self.dmx_to.get_value(),
+            "dmx_from": self.dmx_from.get_value(full=True),
+            "dmx_to": self.dmx_to.get_value(full=True),
             "physical_from": self.physical_from.value,
             "physical_to": self.physical_to.value,
             "wheel_slot_index": self.wheel_slot_index,

pygdtf/utils/__init__.py

@@ -219,8 +219,8 @@ def _create_break_channel(offset, channel, geometry, offset_index):
         "dmx": offset,
         "offset": channel.offset,
         "attribute": "+" * offset_index + str(channel.logical_channels[0].attribute),
-        "default": channel.default.get_value(fine=offset_index > 0),
-        "highlight": channel.highlight.get_value()
+        "default": channel.default.get_value(full=True),
+        "highlight": channel.highlight.get_value(full=True)
         if channel.highlight is not None
         else None,
         "geometry": geometry.name,

pygdtf/value.py

@@ -252,16 +252,26 @@ def __str__(self):
     def __repr__(self):
         return f"Value: {self.value}, Byte count: {self.byte_count}"
 
-    def get_value(self, fine=False):
+    def _get_byte(self, byte_index):
+        if self.byte_count <= 0:
+            return 0
+        if byte_index < 0 or byte_index >= self.byte_count:
+            return 0
+        shift = (self.byte_count - 1 - byte_index) * 8
+        return (self.value >> shift) & 0xFF
+
+    def get_value(self, fine=False, byte_index=None, full=False, components=False):
         if self.byte_count == 1:
             return self.value
-
-        msb = (self.value >> 8) & 0xFF
-        lsb = self.value & 0xFF
-
-        if not fine:
-            return msb
-        return lsb
+        if full:
+            return self.value
+        if components:
+            return [self._get_byte(i) for i in range(self.byte_count)]
+        if byte_index is not None:
+            return self._get_byte(byte_index)
+        if fine:
+            return self._get_byte(self.byte_count - 1)
+        return self._get_byte(0)
 
 
 class PhysicalValue:

tests/test1.json

@@ -0,0 +1,41 @@
+import pygdtf
+
+
+def test_dmx_value_full_and_bytes():
+    value = pygdtf.DmxValue("16909060/4")  # 0x01_02_03_04
+    assert value.get_value(full=True) == 16909060
+    assert value.get_value() == 1
+    assert value.get_value(fine=True) == 4
+    assert value.get_value(components=True) == [1, 2, 3, 4]
+    assert value.get_value(byte_index=1) == 2
+    assert value.get_value(byte_index=2) == 3
+    assert value.get_value(byte_index=3) == 4
+
+
+def test_channel_function_as_dict_full_values():
+    channel_function = pygdtf.ChannelFunction(
+        name="Test",
+        attribute=pygdtf.NodeLink("Attributes", "Dimmer"),
+        dmx_from=pygdtf.DmxValue("16909060/4"),
+        dmx_to=pygdtf.DmxValue("16909061/4"),
+        default=pygdtf.DmxValue("16909062/4"),
+    )
+    result = channel_function.as_dict()
+    assert result["dmx_from"] == 16909060
+    assert result["dmx_to"] == 16909061
+    assert result["default"] == 16909062
+
+
+def test_dmx_channel_as_dict_byte_defaults():
+    channel = pygdtf.DmxChannel(
+        offset=[1, 2, 3, 4],
+        default=pygdtf.DmxValue("16909060/4"),
+        highlight=pygdtf.DmxValue("84281096/4"),  # 0x05_06_07_08
+        attribute=pygdtf.NodeLink("Attributes", "Dimmer"),
+        logical_channels=[
+            pygdtf.LogicalChannel(attribute=pygdtf.NodeLink("Attributes", "Dimmer"))
+        ],
+    )
+    result = channel.as_dict()
+    assert [entry["default"] for entry in result] == [16909060, 16909060, 16909060, 16909060]
+    assert result[0]["highlight"] == 84281096