Added custom LofarDeviceProxy to enhance support for high-dimensional arrays in attribtues

tests/test_devices.py

+import numpy
+
+from tests import base
+
+from lofar_station_client.devices import LofarDeviceProxy
+
+from tango.test_context import MultiDeviceTestContext
+from tango.server import Device, attribute, AttrWriteType
+
+
+class MyDevice(Device):
+    A = attribute(
+        dtype=((bool,),),
+        max_dim_x=4,
+        max_dim_y=6,
+        format="(2,3,4)",
+        access=AttrWriteType.READ_WRITE,
+    )
+
+    scalar = attribute(dtype=bool, access=AttrWriteType.READ_WRITE)
+
+    spectrum = attribute(dtype=(bool,), max_dim_x=2, access=AttrWriteType.READ_WRITE)
+
+    image = attribute(
+        dtype=((bool,),), max_dim_x=2, max_dim_y=3, access=AttrWriteType.READ_WRITE
+    )
+
+    def init_device(self):
+        self.value_A = numpy.zeros((6, 4), dtype=bool)
+        self.value_scalar = False
+        self.value_spectrum = [False, False]
+        self.value_image = [[False, False]] * 3
+
+    def read_scalar(self):
+        return self.value_scalar
+
+    def write_scalar(self, value):
+        self.value_scalar = value
+
+    def read_spectrum(self):
+        return self.value_spectrum
+
+    def write_spectrum(self, value):
+        self.value_spectrum = value
+
+    def read_image(self):
+        return self.value_image
+
+    def write_image(self, value):
+        self.value_image = value
+
+    def read_A(self):
+        return self.value_A
+
+    def write_A(self, value):
+        self.value_A = value
+
+
+class LofarDeviceProxyTest(base.TestCase):
+    TEST_DEVICE_INFO = [
+        {
+            "class": MyDevice,
+            "devices": [{"name": "STAT/MyDevice/1", "properties": {}, "memorized": {}}],
+        }
+    ]
+
+    @classmethod
+    def setUpClass(cls):
+        # setting up the TestContext takes ~1 second, so do it only once
+        cls.context = MultiDeviceTestContext(
+            cls.TEST_DEVICE_INFO,
+            process=True,
+        )
+
+        cls.context.start()
+        cls.proxy = LofarDeviceProxy(cls.context.get_device_access("STAT/MyDevice/1"))
+
+    @classmethod
+    def tearDownClass(cls):
+        # In Python3.8+, we can use addClassCleanup instead
+        cls.context.stop()
+
+    def test_read_scalar(self):
+        value = self.proxy.scalar
+
+        self.assertEqual(bool, type(value))
+
+    def test_write_scalar(self):
+        self.proxy.scalar = True
+
+    def test_read_spectrum(self):
+        value = self.proxy.spectrum
+
+        self.assertEqual((2,), value.shape)
+        self.assertEqual(numpy.bool_, type(value[0]))
+
+    def test_write_spectrum(self):
+        self.proxy.spectrum = [True, False]
+
+    def test_read_image(self):
+        value = self.proxy.image
+
+        self.assertEqual((3, 2), value.shape)
+        self.assertEqual(numpy.bool_, type(value[0, 0]))
+
+    def test_write_image(self):
+        self.proxy.image = [[True, False]] * 3
+
+    def test_write_3D_attribute_lists(self):
+        self.proxy.A = [
+            [True, True, True, True],
+            [True, True, True, True],
+            [True, True, True, True],
+        ], [
+            [False, False, False, False],
+            [False, False, False, False],
+            [False, False, False, False],
+        ]
+
+    def test_write_3D_attribute_numpy(self):
+        self.proxy.A = numpy.zeros((2, 3, 4), dtype=bool)
+
+    def test_write_3D_attribute_numpy_with_too_few_dimensions(self):
+        # write a 2D shape
+        with self.assertRaises(ValueError):
+            self.proxy.A = numpy.zeros((2, 12), dtype=bool)
+
+    def test_write_3D_attribute_numpy_with_too_many_dimension(self):
+        # write a 4D shape
+        with self.assertRaises(ValueError):
+            self.proxy.A = numpy.zeros((2, 3, 2, 2), dtype=bool)
+
+    def test_read_3D_attribute(self):
+        value = self.proxy.A
+
+        self.assertEqual((2, 3, 4), value.shape)